#include <bits/stdc++.h>


using namespace std;


#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


mt19937 rnd(234);
const ll inf = 1e18;


const ll mod = 1e9 + 7;
const ll rv2 = (mod + 1) / 2;


struct SGT{
    struct node{
        typedef node* pnode;
        
        pnode l = nullptr;
        pnode r = nullptr;

        ll sm = 0;
        ll empty_count = 0;
        ll empty_sm = 0;
        ll overflow_count = 0;


        void build(ll tl, ll tr, ll val){
            if(val == 0){
                empty_count = tr - tl + 1;
                empty_sm = ((tr + tl) % mod) * ((tr - tl + 1) % mod) % mod * rv2 % mod;
                sm = 0;
                overflow_count = 0;
            } else{
                empty_count = 0;
                empty_sm = 0;
                overflow_count = (val - 1) * (tr - tl + 1);
                sm = ((tr + tl) % mod) * ((tr - tl + 1) % mod) % mod * rv2 % mod;
            }
        }


        node(ll tl, ll tr, ll val){
            build(tl, tr, val);
        }


        void push(ll tl, ll tr){
            ll tm = (tl + tr) / 2;
            if(l == nullptr){
                l = new node(tl, tm, 0);
            }
            if(r == nullptr){
                r = new node(tm + 1, tr, 0);
            }
        }
    };

    typedef node* pnode;


    void go_deep(pnode v, ll tl, ll tr, ll &overflow, ll &sm, ll &empty_count, ll &empty_sm){
        if(v == nullptr){
            if(overflow >= (tr - tl + 1)){
                sm = (sm + ((tr + tl) % mod) * ((tr - tl + 1) % mod) % mod * rv2) % mod;
                overflow -= (tr - tl + 1);
            } else{
                ll mtr = (tl + overflow - 1);
                ll mtl = mtr + 1;
                sm = (sm + ((mtr + tl) % mod) * ((mtr - tl + 1) % mod) % mod * rv2) % mod;
                empty_sm = (empty_sm + ((tr + mtl) % mod) * ((tr - mtl + 1) % mod) % mod * rv2) % mod;
                empty_count += (tr - mtl + 1);
                overflow = 0;
            }
            return;
        }
        if(overflow == 0){
            empty_count += v->empty_count;
            empty_sm = (empty_sm + v->empty_sm) % mod;
            return;
        }
        if(overflow >= v->empty_count){
            sm = (sm + v->empty_sm) % mod;
            overflow -= v->empty_count;
            return;
        }
        ll tm = (tl + tr) / 2;
        // v->push(tl, tr);
        go_deep(v->l, tl, tm, overflow, sm, empty_count, empty_sm);
        go_deep(v->r, tm + 1, tr, overflow, sm, empty_count, empty_sm);
    }


    void upd(pnode v, ll tl, ll tr){
        ll tm = (tl + tr) / 2;
        auto l = v->l;
        auto r = v->r;
        v->overflow_count = r->overflow_count;
        v->sm = (l->sm + r->sm) % mod;
        v->empty_sm = l->empty_sm;
        v->empty_count = l->empty_count;
        ll left_overflow = l->overflow_count;
        go_deep(r, tm + 1, tr, left_overflow, v->sm, v->empty_count, v->empty_sm);
        v->overflow_count += left_overflow;
    }

    ll glob_tl, glob_tr;
    pnode root;


    void build(ll tl, ll tr){
        glob_tl = tl;
        glob_tr = tr;
        root = new node(tl, tr, 0);
    }


    void chng(pnode v, ll tl, ll tr, ll i, ll x){
        if(tl == i && tr == i){
            v->build(tl, tr, x);
            return;
        }
        v->push(tl, tr);
        ll tm = (tl + tr) / 2;
        if(i <= tm){
            chng(v->l, tl, tm, i, x);
        } else{
            chng(v->r, tm + 1, tr, i, x);
        }
        upd(v, tl, tr);
    }


    void chng(ll i, ll x){
        chng(root, glob_tl, glob_tr, i, x);
    }


    ll get(){
        return root->sm;
    }
};


SGT sgt;


int32_t main(){
    if(1){
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    sgt.build(0, 10000);
    int n;
    cin >> n;
    while(n--){
        ll pos, x;
        cin >> pos >> x;
        sgt.chng(pos, x);
        cout << sgt.get() << "\n";
    }
    return 0;
}