#include<bits/stdc++.h>
using namespace std;
#define maxn 200050
#define int long long
int n,m;
int A[maxn+10];
int st[maxn+10][2];
namespace radix{
    int re[(maxn<<1)+20];
    void work(){
        int tmp[(maxn<<1)+20];
        for(int i = 1;i<=2*n;++i){
            tmp[i] = A[i];
        }
        sort(tmp+1,tmp+n+1);
        for(int i = 0;i<=2*n;++i){
            int p = lower_bound(tmp,tmp+n,A[i]) - tmp;
            int t = A[i];
            re[p] = A[i];
            A[i] = p;
        }
    }
}
namespace hjtsegtree{
    int tot;
    int sum[(maxn<<5)+10],roots[maxn+10]
    ,ls[(maxn<<5)+10],rs[(maxn<<5)+10];
    int d[(maxn<<5)+10];
    int size;
    int build(int l=1,int r=size){
        int root = ++tot;
        if(l == r)return root;
        int m = l+((r-l)>>1);
        ls[root] = build(l,m);
        rs[root] = build(m+1,r);
        return root;
    }

/**
 * insert(re[A[i]], A[i], root, l, r)
 * re[A[i]] : original value
 * A[i] : radixed position
 */
    int insert(int k,int x,int root,int l=1,int r=size){
        int dir = ++tot;
        ls[dir] = ls[root],rs[dir] = rs[root],
        sum[dir] = sum[root]+(k>0 ? 1 : -1), d[dir] = d[root] + k;
        if(l == r)return dir;
        int mid = l+((r-l)>>1);
        if(x<=mid)
            ls[dir] = insert(k,x,ls[dir],l,mid);
        else
            rs[dir] = insert(k,x,rs[dir],mid+1,r);
        return dir;
    }

    /*int query(int t,int root,int k,int remainder,int l=1,int r=size){
        int mid = l+r>>1;
        int x = sum[ls[t]];
        if(l==r){
            return l*remainder;
        }
        if(k<=x) return query(ls[t],k,remainder,l,mid);
        else return d[ls[t]]+query(rs[t],k,remainder-sum[ls[t]],mid+1,r);
    }*/

    /**
     * k: the first k-th elements & current remaining element count
     * root: current root
     */
    int query(int k,int root, int l=1,int r=size){
        int m = l+r>>1;
        int x = sum[ls[root]];
        if(l == r){
            return radix::re[l] * min(sum[root],k);
        }
        if(k <= x) return query(k,ls[root],l,m);//query the left subtree
        else return d[ls[root]] + query(k-sum[ls[root]],rs[root],m+1,r);
    }
};

class node{
public:
    int time,val,reval;
    node(){}
    node(int _t,int _v,int _r):time(_t),val(_v),reval(_r){}
};

vector<node> seq;
using hjtsegtree::roots;

signed main(){
    cin >> n >> m ;
    hjtsegtree::size = n;
    roots[0] = hjtsegtree::build();
    for(int i = 0;i<n;++i){
        cin >> st[i][0] >> st[i][1] >> A[i];
    }
    radix::work();
    for(int i = 0;i<n;++i){
        seq.push_back(node(st[i][0],radix::re[A[i]],A[i])),seq.push_back(node(st[i][1]+1,-radix::re[A[i]],A[i]));
    }
    sort(seq.begin(),seq.end(),[](node a,node b){return a.time < b.time;});
    int lastroot = roots[0],lasttime = -1;
    for(int i = 0;i<n<<1;++i){
        int crtroot = hjtsegtree::insert(seq[i].val,seq[i].reval,lastroot);
        roots[seq[i].time] = crtroot;
        lastroot = crtroot;
    }
    for(int i = 0;i<n<<1;++i){
        if(roots[i]==0)roots[i] = roots[i-1];
    }
    int pre = 1;
    while(m--){
        int x,a,b,c;
        cin >> x >> a >> b >> c;
        int k = 1 + (a * pre + b) % c;
        pre = hjtsegtree::query(k,hjtsegtree::roots[x]);
        cout << pre << '\n';
    }
    return 0;
}