1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
#include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;

const ll mod=1'000'000'000+7;
const ll siz=1<<19;

struct xd{
    ll ad;
    ll mn;
};

xd tri[2*siz+7];
int nxt[500007];
int presum[500007];
xd tab[500007];

vector <xd> rid(int l, int r){
    l+=siz-1;
    r+=siz+1;
    vector<xd> rans;
    vector<xd> ans;
    while(l+1<r){
        if(l%2==0){
            ans.push_back(tri[l+1]);
        }
        if(r%2==1){
            rans.push_back(tri[r-1]);
        }
        l/=2;
        r/=2;
    }
    while(!rans.empty()){
        ans.push_back(rans.back());
        rans.pop_back();
    }
    return ans;
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n, an=0, r, q, i, j, a, k, b, x;
    cin >> n >> q;
    for(i=0; i<n; i++){
        cin >> tab[i].ad >> tab[i].mn;
        if(tab[i].mn==1){
            tri[siz+i] = tab[i];
        }
        else{
            tri[siz+i]={0, tab[i].mn};
        }
        if(i==0){
            presum[i]=tab[i].ad;   
        }
        else{
            presum[i]=tab[i].ad+presum[i-1];
        }
    }
    tab[n]={0,1};
    nxt[n]=n;
    for(i=n-1; i>=0; i--){
        if(tab[i].mn==1){
            nxt[i]=nxt[i+1];
        }
        else{
            nxt[i]=i;
        }
    }
    for(i=siz-1; i>0; i--){
        tri[i].ad=tri[2*i].ad*tri[2*i+1].mn+tri[2*i+1].ad;
        tri[i].mn=tri[2*i].mn*tri[2*i+1].mn;
        tri[i].ad%=mod;
        tri[i].mn%=mod;
    }
    //wszystko zsetupowane
    for(int Q=0; Q<q; Q++){
        cin >> x >> a >> b;
        b--;
        while(x<mod && a<=b){
            if(tab[a].mn==1){
                int ne=min(nxt[a], b+1);
                x+=presum[ne-1];
                if(a>0){
                    x-=presum[a-1];
                }
                a=ne;
            }
            else{
                x=max(x+tab[a].ad, x*tab[a].mn);
                a++;
            }
        }
        x%=mod;
        vector<xd> pro=rid(a,b);
        for(auto z:pro){
            x*=z.mn;
            x+=z.ad;
            x%=mod;
        }
        cout << x << '\n';
    }
}