#include <bits/stdc++.h>

using namespace std;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
using ll = long long;
#define int ll
using ld = long double;
using pii = pair<int, int>;

#define F first
#define S second

const ld PI = 3.1415926535;
const int N = 1e5 + 5;
const int M = 1e5 + 1;
ll mod = 1e9 + 7;
const int infi = 1e9;
const ll infl = 1e16;
const int P = 31;

int mult(int a, int b) { return a * 1LL * b % mod; }

int sum(int a, int b) {
    if(a + b >= mod)
        return a + b - mod;
    if(a + b < 0)
        return a + b + mod;
    return a + b;
}

ll binpow(ll a, ll n) {
    if (n == 0) return 1;
    if (n % 2 == 1) {
        return binpow(a, n - 1) * a % (mod + 1);
    } else {
        ll b = binpow(a, n / 2);
        return b * b % (mod + 1);
    }
}

struct segtree_with_rollbacks{
    int t[M], sm[M], cnt[M], lc[M], rc[M], cur = 1;
    vector<pair<int, pii>> ver;

    int pr(int v){
        if(rc[v] == 0)
            rc[v] = ++cur;
        return rc[v];
    }

    int lv(int v){
        if(lc[v] == 0){
            lc[v] = ++cur;
        }
        return lc[v];
    }

    void scnt(int v, int x){
        ver.push_back({2, {v, cnt[v]}});
        cnt[v] = x;
    }

    void ssm(int v, int x){
        ver.push_back({1, {v, sm[v]}});
        sm[v] = x;
    }

    void st(int v, int x){
        ver.push_back({0, {v, t[v]}});
        t[v] = x;
    }

    void save(){
        ver.push_back({-1, {-1, -1}});
    }

    void roll_back(){
        ver.pop_back();
        while(ver.size() > 0 && ver.back().first != -1){
            if(ver.back().first == 0){
                t[ver.back().second.first] = ver.back().second.second;
            }else if(ver.back().first == 1){
                sm[ver.back().second.first] = ver.back().second.second;
            }else{
                cnt[ver.back().second.first] = ver.back().second.second;
            }
            ver.pop_back();
        }
    }

    void push(int v, int tl, int tr){
        if(tl == tr || t[v] == 0)
            return;
        int tm = (tl + tr) / 2;
        st(lv(v), t[v]);
        st(pr(v), t[v]);
        ssm(lv(v), ((tl + tm) * (tm - tl + 1) / 2) % mod);
        ssm(pr(v), ((tr + tm + 1) * (tr - tm) / 2) % mod);
        scnt(lv(v), tm - tl + 1);
        scnt(pr(v), tr - tm);
        st(v, 0);
    }

    void upd(int v, int tl, int tr, int l, int r){
        push(v, tl, tr);
        if(tl > r || l > tr){
            return;
        }
        if(l <= tl && tr <= r){
            st(v, 1);
            ssm(v, ((tl + tr) * (tr - tl + 1) / 2) % mod);
            scnt(v, tr - tl + 1);
            return;
        }
        int tm = (tl + tr) / 2;
        upd(lv(v), tl, tm, l, r);
        upd(pr(v), tm + 1, tr, l, r);
        ssm(v, (sm[lv(v)] + sm[pr(v)]) % mod);
        scnt(v, cnt[lv(v)] + cnt[pr(v)]);
    }

    int getcnt(int v, int tl, int tr, int l, int r){
        push(v, tl, tr);
        if(tl > r || l > tr)
            return 0;
        if(l <= tl && tr <= r)
            return cnt[v];
        int tm = (tl + tr) / 2;
        return getcnt(lv(v), tl, tm, l, r) + getcnt(pr(v), tm + 1, tr, l, r);
    }

    int getr(int v, int tl, int tr, int x, int prev){
        push(v, tl, tr);
        if(tl == tr){
            return tr;
        }
        int tm = (tl + tr) / 2;
        if(tm - (prev + cnt[lv(v)]) >= x)
            return getr(lv(v), tl, tm, x, prev);
        return getr(pr(v), tm + 1, tr, x, prev + cnt[lv(v)]);
    }
} t;

int n, ans[N];
map<int, vector<pii>> mp;
vector<pii> ops[4 * N];

void add(int v, int tl, int tr, int l, int r, pii x){
    if(tl > r || l > tr)
        return;
    if(l <= tl && tr <= r){
        ops[v].push_back(x);
        return;
    }
    int tm = (tl + tr) / 2;
    add(2 * v, tl, tm, l, r, x);
    add(2 * v + 1, tm + 1, tr, l, r, x);
}

void dfs(int v, int tl, int tr){
    for(auto e : ops[v]){
        int d = e.first, x = e.second;
        int pr = t.getcnt(1, 1, 1e18, 1, d - 1);
        int r = t.getr(1, 1, 1e18, d - 1 - pr + x, 0);
        t.upd(1, 1, 1e18, d, r);
    }
    t.save();
    if(tl == tr){
        ans[tl] = t.sm[1];
        t.roll_back();
    }else{
        int tm = (tl + tr) / 2;
        dfs(2 * v, tl, tm);
        dfs(2 * v + 1, tm + 1, tr);
        t.roll_back();
    }
}

void solve() {
    cin >> n;
    for(int i = 1; i <= n; i++){
        int d, cnt;
        cin >> d >> cnt;
        mp[d].push_back({i, cnt});
    }
    for(auto e : mp){
        int da = e.first;
        vector<pii> v = e.second;
        v.push_back({n + 1, 0});
        for(int i = 0; i < v.size() - 1; i++){
            int l = v[i].first, r = v[i + 1].first - 1;
            add(1, 1, n, l, r, {da, v[i].second});
        }
    }
    dfs(1, 1, n);
    for(int i = 1; i <= n; i++)
        cout << ans[i] << '\n';
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}