LazyPropagationWithPolynomial

#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>

using namespace std;

#define ll long long
ll M = 1000000007;

ll calcZero(ll l, ll r) {
    return (ll)(r - l) % M;
}

ll calcFirst(ll l, ll r) {
    return (ll)((r*(r - 1) - l*(l - 1)) / 2) % M;
}

ll calcSecond(ll l, ll r) {
    return (ll)((r*(r - 1)*(2 * r - 1) - l*(l - 1)*(2 * l - 1)) / 6) % M;
}

ll calcSum(ll l, ll r, ll a, ll b, ll c) {
    return (a*calcSecond(l, r) + b*calcFirst(l, r) + c*calcZero(l, r) + 3*M) % M;
}

struct vertex{

    int num;
    ll left, right;
    ll a, b, c;
    bool unPushed;
    ll sum;

    vertex() {
        num = 0;
        a = b = c = 0;
        unPushed = false;
        sum = 0;
    }

    void print() {
        cerr << num << " - num\n";
        cerr << left << " " << right << " l r\n";
        cerr << a << " " << b << " " << c << " a b c\n";
        cerr << unPushed << " unPushed\n";
        cerr << sum << " sum\n";
        cerr << "\n";
    }

};

class PolynomialSegmentTree {

    int length;
    vector<vertex> vertice;

    void build(int num, ll l, ll r) {
        vertice[num].num = num;
        vertice[num].left = l, vertice[num].right = r;
        if (r > l + 1) {
            ll m = (l + r) / 2;
            build(2 * num + 1, l, m);
            build(2 * num + 2, m, r);
        }
    }

    void makePush(int num) {
        vertice[num].unPushed = false;
        if (vertice[num].right > vertice[num].left + 1){
            vertice[2 * num + 1].a += vertice[num].a;
            vertice[2 * num + 1].b += vertice[num].b;
            vertice[2 * num + 1].c += vertice[num].c;

            vertice[2 * num + 2].a += vertice[num].a;
            vertice[2 * num + 2].b += vertice[num].b;
            vertice[2 * num + 2].c += vertice[num].c;

            vertice[2 * num + 1].a %= M;
            vertice[2 * num + 1].b %= M;
            vertice[2 * num + 1].c %= M;

            vertice[2 * num + 2].a %= M;
            vertice[2 * num + 2].b %= M;
            vertice[2 * num + 2].c %= M;

            vertice[2 * num + 1].unPushed = true;
            vertice[2 * num + 2].unPushed = true;
        }
        vertice[num].sum = (vertice[num].sum + calcSum(vertice[num].left, vertice[num].right, vertice[num].a, vertice[num].b, vertice[num].c) + 3*M) % M;
        vertice[num].a = 0;
        vertice[num].b = 0;
        vertice[num].c = 0;
    }

    void add(int num, ll l, ll r, ll a, ll b, ll c) {

        if (l >= r)
            return;

        ll left = vertice[num].left;
        ll right = vertice[num].right;

        if (left == l && right == r) {
            vertice[num].a += a;
            vertice[num].b += b;
            vertice[num].c += c;
            vertice[num].unPushed = true;
            return;
        }

        vertice[num].sum = (vertice[num].sum + calcSum(l, r, a, b, c)) % M;

        ll mid = (left + right) / 2;

        add(2 * num + 1, l, min(mid, r), a, b, c);
        add(2 * num + 2, max(mid, l), r, a, b, c);

    }

    ll askSum(int num, ll l, ll r) {
        if (l >= r)
            return 0;

        if (vertice[num].unPushed) {
            makePush(num);
        }

        if (vertice[num].left == l && vertice[num].right == r)
            return vertice[num].sum;
        ll mid = (vertice[num].left + vertice[num].right) / 2;
        return (askSum(2 * num + 1, l, min(mid, r)) + askSum(2 * num + 2, max(mid, l), r) + 3*M) % M;
    }


public:

    PolynomialSegmentTree(int n) {
        length = 4 * n;
        vertice.resize(length);
        build(0, 0, n);
    }

    void add(ll l, ll r) {
        add(0, l, r, 1, -(2 * l - 3), ((l - 1)*(l - 2)) % M);
    }

    ll ask(ll l, ll r) {
        return askSum(0, l, r);
    }

    void print() {
        for (int i = 0; i < length; ++i)
            vertice[i].print();
    }

};

int main() {
ofstream fout("output.txt");
    /*int nn, qq;
    nn = 20000;
    qq = 50;

    fout << nn << " " << qq << "\n";

    for (int i = 0; i < qq; ++i) {
        int a = rand() % nn + 1;
        int b = rand() % nn + 1;
        if (a > b)
            swap(a, b);
        fout << rand() % 2 + 1 << " " << a << " " << b << "\n";
    }
return 0;*/

    int n, q;
    cin >> n >> q;

    PolynomialSegmentTree cTree(n);

    for (ll i = 0; i < q; ++i) {
    //  cTree.print();
        ll type, x, y;
        cin >> type >> x >> y;
    //  cerr << "azazazazdfjwfijfwifrjfiejgiojrgijreifjrgfiergjergrgtrgergerggeqgrgregerg\n";
        if (type == 1) {
            cTree.add(x - 1, y);
        }
        if (type == 2) {
            fout << cTree.ask(x - 1, y) << "\n";
        }

    }

    //system("pause");

    return 0;
}