//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;
template<class T>
using vec = vector<T>;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}
template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#ifdef KoRoVa
#define DEBUG for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define DEBUG while (false)
#define LOG(...)
#endif

const int max_n = 5e5 + 11, inf = 1000111222;

const int mod = 1e9 + 7;


inline void inc(int &x, int y) {
    x += y;
    if (x >= mod) {
        x -= mod;
    }
}

inline void dec(int &x, int y) {
    x -= y;
    if (x < 0) {
        x += mod;
    }
}

inline int neg (int x) {
    return x ? mod - x : 0;
}

inline int mul(int x, int y) {
    return (1LL * x * y) % mod;
}

int power(int x, int y) {
    if (y < 0) {
        y += mod - 1;
    }
    if (y == 0) {
        return 1;
    }
    if (y % 2 == 0) {
        return power(mul(x, x), y / 2);
    }
    return mul(x, power(x, y - 1));
}

inline int inv(int x) {
    return power(x, mod - 2);
}


// new mint part


inline int divide (int x, int y) {
    return mul(x, inv(y));
}

struct mint {
#define oper_apply(op, f) mint& operator op (const mint &x) {f(val, x.val); return *this;}
#define oper_apply_const(op, f) mint operator op (const mint &x) const {mint tmp = *this; f(tmp.val, x.val); return tmp;}
#define oper_return(op, f) mint& operator op (const mint &x) {val = f(val, x.val); return *this;}
#define oper_return_const(op, f) mint operator op (const mint &x) const {return mint(f(val, x.val));}

    int val;

    mint(int x = 0) : val(x) {}

    oper_apply(+=, inc);
    oper_apply_const(+, inc);
    oper_apply(-=, dec);
    oper_apply_const(-, dec);
    oper_return(*=, mul);
    oper_return_const(*, mul);
    oper_return(/=, divide);
    oper_return_const(/, divide);
    oper_return(^=, power);
    oper_return_const(^, power);
};

const int max_f = 11;
const int max_rf = max_f;
static_assert(max_f >= 1 && max_rf >= 1);

mint f[max_f], rf[max_rf];

bool frf_calculated = []() {
    f[0] = 1;
    for (int i = 1; i < max_f; ++i) {
        f[i] = f[i - 1] * mint(i);
    }
    mint x = f[min(max_f, max_rf) - 1];
    for (int i = max_f; i < max_rf; ++i) {
        x *= mint(i);
    }
    rf[max_rf - 1] = inv(x.val);
    for (int i = max_rf - 2; i >= 0; --i) {
        rf[i] = rf[i + 1] * mint(i + 1);
    }
    return true;
}();

inline mint A (int n, int k) {
    if (k < 0 || k > n) return 0;
    return f[n] * rf[n - k];
}

inline mint C (int n, int k) {
    if (k < 0 || k > n) return 0;
    return A(n, k) * rf[k];
}

int a[max_n], b[max_n], to[max_n];

ll pref[max_n];

struct node {

    mint k, b;

    /// not existing node
    node () : k(1), b(0) {}


};



inline node pull (node a, node b) {
    node res;
    res.k = b.k * a.k;
    res.b = b.b + a.b * b.k;
    return res;
}

struct segment_tree {
    vector <node> t;
    int n;

    segment_tree () {}

    inline void build (int v, int tl, int tr) {
        if (tl == tr) {
            if (b[tr] == 1) {
                t[v].k = 1;
                t[v].b = a[tr];
            }
            else {
                t[v].k = b[tr];
                t[v].b = 0;
            }
            return;
        }
        int tm = (tl + tr) >> 1;
        build(v << 1, tl, tm);
        build(v << 1 | 1, tm + 1, tr);
        t[v] = pull(t[v << 1], t[v << 1 | 1]);
    }

    segment_tree (int n) : n(n){
        t.resize(4 * n);
        build(1, 0, n - 1);
    }

    inline void push (int v, int tl, int tr) {

    }

    inline void update (int v, int tl, int tr, int l, int r, int x) { /// think
        push(v, tl, tr);
        if (l > r) return;
        if (tl == l && tr == r) { /// think
            // t[v]
            push(v, tl, tr);
            return;
        }
        int tm = (tl + tr) >> 1;
        update(v << 1, tl, tm, l, min(r, tm), x);
        update(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r, x);
        t[v] = pull(t[v << 1], t[v << 1 | 1]);
    }


    inline node query (int v, int tl, int tr, int l, int r) {
        push(v, tl, tr);
        if (l > r) return node();
        if (tl == l && tr == r) {
            return t[v];
        }
        int tm = (tl + tr) >> 1;
        return pull(query(v << 1, tl, tm, l, min(r, tm)), query(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r));
    }

    inline void upd (int l, int r, int x) {
        update(1, 0, n - 1, l, r, x);
    }


    inline node get (int l, int r) {
        return query(1, 0, n - 1, l, r);
    }
};

int nxt[max_n];

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n, q;
    cin >> n >> q;
    for (int i = 0; i < n; i++) {
        cin >> a[i] >> b[i];
        pref[i] = a[i];
        if (i) {
            pref[i] += pref[i - 1];
        }
    }
    int last = n;
    for (int i = n - 1; i >= 0; i--) {
        if (b[i] > 1) {
            last = i;
        }
        to[i] = last;
    }
    last = n;
    for (int i = n - 1; i >= 0; i--) {
        if (a[i] > 0) {
            last = i;
        }
        nxt[i] = last;
    }

    auto get_pref = [&] (int l, int r) -> ll {
        if (l > r) {
            return 0LL;
        }
        return pref[r] - (l ? pref[l - 1] : 0LL);
    };
    ll x;
    int l, r;

    segment_tree t(n);
    for (int i = 0; i < q; i++) {
        cin >> x >> l >> r;

        if (x == 0) {
            int go = nxt[l];
            if (go < r) {
                x = a[go];
                l = go + 1;
            }
            else {
                l = r;
            }
        }


        while (x <= mod && l < r) {
            int go = min(r, to[l]);
            x += get_pref(l, go - 1);
            l = go;
            if (x >= mod) {
                break;
            }

            if (l < r) {
                x = max(x + a[l], x * b[l]);
            }
            ++l;
        }

        x %= mod;
//        LOG(l, r, x);

        node res = t.get(l, r - 1);
        mint ans = mint(x) * res.k + res.b;





        cout << ans.val << '\n';
    }
}

/*
KoRoVa!
*/