#include <iostream>
#include <vector>
#include <cassert>

class Liczba
{
    static constexpr long long DZIELNIK = 1000000007;
public:
    bool czyDuza = false;
    long long liczba = 0;
    Liczba(long long liczbaArg) :
        liczba(liczbaArg)
    {
    }

    Liczba operator+(Liczba const& druga) const
    {
        Liczba result = *this;
        result.liczba += druga.liczba;
        if (result.liczba >= DZIELNIK)
        {
            result.liczba -= DZIELNIK;
            result.czyDuza = true;
        }
        return result;
    }

    Liczba operator*(Liczba const& druga) const
    {
        Liczba result = *this;
        result.liczba *= druga.liczba;
        if (result.liczba >= DZIELNIK)
        {
            result.liczba %= DZIELNIK;
            result.czyDuza = true;
        }
        return result;
    }

    bool czyMnozenieDajeWiekszyWynik(int dodajnik, int mnoznik) const
    {
        if (czyDuza)
            return true;
        return (liczba * mnoznik) >= (liczba + dodajnik);
    }

    friend std::ostream& operator<<(std::ostream& stream, Liczba const& liczba)
    {
        stream << liczba.liczba;
        return stream;
    }
};

struct Funkcja
{
    Liczba a = 1;
    Liczba b = 0;
    Funkcja polacz(Funkcja const& druga) const
    {
        Funkcja result;
        result.a = a * druga.a;
        result.b = b * druga.a + druga.b;
        return result;
    }
};

class DrzewoPrzedzialowe
{
private:
    long long ROZMIAR_DRZEWA = 1;
    std::vector<Funkcja> elementy;
    Funkcja getPrzedzial(int a, int b, int u, int low, int high)
    {
        if (a == low && b == high)
            return elementy[u];
        if (b <= a)
            return Funkcja();
        int mid = (low + high) / 2;
        Funkcja lewy = getPrzedzial(a, std::min(mid, b), 2 * u, low, mid);
        Funkcja prawy = getPrzedzial(std::max(mid, a), b,  2 * u + 1, mid, high);
        return lewy.polacz(prawy);
    }
public:
    DrzewoPrzedzialowe(int n)
    {
        while (ROZMIAR_DRZEWA <= n)
        {
            ROZMIAR_DRZEWA *= 2;
        }
        elementy.resize(2*ROZMIAR_DRZEWA);
    }
    void ustaw(int pozycjaArg, Funkcja const& funkcja)
    {
        assert(pozycjaArg >= 0 && pozycjaArg < ROZMIAR_DRZEWA);
        int pozycja = pozycjaArg + (int)ROZMIAR_DRZEWA;
        elementy[pozycja] = funkcja;
        while (pozycja > 0)
        {
            int ojciec = pozycja / 2;
            elementy[ojciec] = elementy[2 * ojciec].polacz(elementy[2 * ojciec + 1]);
            pozycja = ojciec;
        }
    }

    Funkcja getPrzedzial(int a, int b)
    {
        assert(a >= 0 && a <= b && b <= ROZMIAR_DRZEWA);
        return getPrzedzial(a, b, 1, 0, (int)ROZMIAR_DRZEWA);
    }
};

struct Mnoznik
{
    int indeks;
    int dodajnik = 0; // dodawanie
    int mnoznik = 1; //mnozenie;
    Liczba sumaPorzednich = 0;
};

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    int n;
    int q;
    std::cin >> n >> q;
    std::vector<Mnoznik> mnozniki;
    std::vector<int> dodajniki;
    DrzewoPrzedzialowe drzewoPrzedzialowe(n);
    Liczba sumaPoprzednich = 0;
    for (int i = 0; i < n; ++i)
    {
        int pierwszyWybor;
        int drugiWybor;
        std::cin >> pierwszyWybor >> drugiWybor;
        if (drugiWybor == 1)
        {
            Funkcja funkcja;
            funkcja.a = 1;
            funkcja.b = pierwszyWybor;
            drzewoPrzedzialowe.ustaw(i, funkcja);
            sumaPoprzednich = sumaPoprzednich + pierwszyWybor;
        }
        else
        {
            Funkcja funkcja;
            funkcja.a = drugiWybor;
            funkcja.b = 0;
            drzewoPrzedzialowe.ustaw(i, funkcja);
            Mnoznik mnoznik;
            mnoznik.indeks = i;
            mnoznik.dodajnik = pierwszyWybor;
            mnoznik.mnoznik = drugiWybor;
            mnoznik.sumaPorzednich = sumaPoprzednich;
            sumaPoprzednich = 0;
            mnozniki.push_back(mnoznik);
        }
        if (pierwszyWybor > 0)
            dodajniki.push_back(i);
    }
    Mnoznik koncowyStraaznik;
    koncowyStraaznik.indeks = n;
    koncowyStraaznik.dodajnik = 0;
    koncowyStraaznik.mnoznik = 1;
    koncowyStraaznik.sumaPorzednich = sumaPoprzednich;
    mnozniki.push_back(koncowyStraaznik);

    //Funkcja f = drzewoPrzedzialowe.getPrzedzial(7, 8);

    for (int i = 0; i < q; ++i)
    {
        int poczatkowaWartosc;
        int start;
        int end;
        std::cin >> poczatkowaWartosc >> start >> end;

        if (poczatkowaWartosc == 0)
        {
            auto dodajnikiIt = std::lower_bound(dodajniki.begin(), dodajniki.end(), start);
            if (dodajnikiIt == dodajniki.end())
            {
                std::cout << "0\n";
                continue;
            }
            start = std::min(*dodajnikiIt, end);
        }
        Mnoznik pierwszy;
        pierwszy.indeks = start;
        auto it = std::lower_bound(mnozniki.begin(), mnozniki.end(), pierwszy,
            [](const Mnoznik& a, const Mnoznik& b) {return a.indeks < b.indeks; });

        Liczba obecnaLiczba = poczatkowaWartosc;
        Funkcja fun = drzewoPrzedzialowe.getPrzedzial(start, std::min(it->indeks, end));
        assert(fun.a.liczba == 1);
        obecnaLiczba = obecnaLiczba + fun.b;
        start = std::min(it->indeks, end);
        while (obecnaLiczba.czyDuza == false && start < end)
        {
            if (obecnaLiczba.czyMnozenieDajeWiekszyWynik(it->dodajnik, it->mnoznik))
                obecnaLiczba = obecnaLiczba * it->mnoznik;
            else
                obecnaLiczba = obecnaLiczba + it->dodajnik;
            start++;
            auto next_it = it + 1;
            if (next_it == mnozniki.end() || next_it->indeks >= end)
                break;
            obecnaLiczba = obecnaLiczba + next_it->sumaPorzednich;
            start = next_it->indeks;
            it++;
        }

        Funkcja funKoncowa = drzewoPrzedzialowe.getPrzedzial(start, end);
        obecnaLiczba = (obecnaLiczba * funKoncowa.a) + funKoncowa.b;
        std::cout << obecnaLiczba << "\n";
    }

    return 0;
}