#include<bits/stdc++.h>

using namespace std;

#define MAXN 200010

typedef long long LL;

int n , m , idx , version;

int S[MAXN] , E[MAXN] , P[MAXN] , root[MAXN * ] , cnt[MAXN * ] , tmp[MAXN * ] , lson[MAXN * ] , rson[MAXN * ] , rt[MAXN * ];

LL sum[MAXN * ];

multiset< int > ins[MAXN] , del[MAXN];

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }

template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }

template <typename T> inline void read(T &x)

{

    T f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

inline void build(int &k , int l , int r)

{

        k = ++idx;

        cnt[k] = sum[k] = ;

        if (l == r) return;

        int mid = (l + r) >> ;

        build(lson[k] , l , mid);

        build(rson[k] , mid +  , r);

}

inline void modify(int &k , int old , int l , int r , int x , int value)

{

        k = ++idx;

        lson[k] = lson[old] , rson[k] = rson[old];

        cnt[k] = cnt[old] + value;

        sum[k] = sum[old] + 1LL * tmp[x] * value;

        if (l == r) return;

        int mid = (l + r) >> ;

        if (mid >= x) modify(lson[k] , lson[k] , l , mid , x , value);

        else modify(rson[k] , rson[k] , mid +  , r , x , value);

}

inline LL query(int &k , int l , int r , int x)

{

    if (l == r) return 1LL * tmp[l] * min(x , cnt[k]);

    int mid = (l + r)    >> ;

    if (cnt[lson[k]] >= x) return query(lson[k] , l , mid , x);

    else return sum[lson[k]] + query(rson[k] , mid +  , r , x - cnt[lson[k]]);

}

int main()

{

        read(n); read(m);

        for (int i = ; i <= n; i++)

        {

              read(S[i]);

                read(E[i]);

              read(P[i]);

              tmp[i] = P[i];

        }

        sort(tmp +  , tmp + n + );

        int len = unique(tmp +   , tmp + n + ) - tmp - ;

        for (int i = ; i <= n; i++)

        {

                P[i] = lower_bound(tmp +   , tmp + len +  , P[i]) - tmp;

                ins[S[i]].insert(P[i]);

                del[E[i] + ].insert(P[i]);

        }

        build(root[version = ] ,  , len);

        for (int i = ; i <= n; i++)

        {

                for (multiset< int > :: iterator it = ins[i].begin(); it != ins[i].end(); it++)

                {

                        int t = (*it);

                        modify(root[++version] , root[version] ,  , n , t , );

                }

                for (multiset< int > :: iterator it = del[i].begin(); it != del[i].end(); it++)

                {

                        int t = (*it);

                        modify(root[++version] , root[version] ,  , n , t , -);

                }

                rt[i] = version;

        }

        LL pre = ;

        for (int i = ; i <= m; i++)

        {

            LL xi , ai , bi , ci;

            read(xi); read(ai); read(bi); read(ci);

            int ki = (1LL * ai * (pre % ci) % ci + bi % ci) % ci + ;

            printf("%lld\n" , pre = query(root[rt[xi]] ,  , n , ki));

        }

        return ;

}