# include <bits/stdc++.h>
int maxn=0;
using namespace std;
const int mod=1e9+7,inv=5e8+4;
const long long inf=2e14;   
int n,ans[100010],ro;
pair<long long,int> op[100010];
map<long long,pair<int,int> > mp;
struct Second_Segment_Tree {
    int cnt=0;
    struct node { int son[2],sum,cnt;} f[10000010];
    struct operation {
        int x,vl;
        operation() {}
        operation(int _x,int _vl) { x=_x, vl=_vl;}
    };
    vector<operation> op;
    void pushup_(int x,long long l,long long r) {
        long long mid=(l+r)>>1; 
        op.push_back(operation(x,f[x].sum)), f[x].sum=(f[f[x].son[0]].sum+f[f[x].son[1]].sum)%mod;
        op.push_back(operation(x+1e8,f[x].cnt)), f[x].cnt=min((long long)1e9+7,(f[x].son[0] ? (long long)f[f[x].son[0]].cnt : mid-l+1)+(f[x].son[1] ? (long long)f[f[x].son[1]].cnt : r-mid));
    }
    int cover_(int x,long long l,long long r,long long lpos,long long rpos) {
        if (!x) x=++cnt, f[x].cnt=min((long long)1e9+7,r-l+1);
        if (f[x].cnt==0) return x;
        if (lpos<=l&&r<=rpos) {
            op.push_back(operation(x,f[x].sum)), f[x].sum=(l+r)%mod*((r-l+1)%mod)%mod*inv%mod;
            op.push_back(operation(x+1e8,f[x].cnt)), f[x].cnt=0;
            return x;
        }
        long long mid=(l+r)>>1;
        if (lpos<=mid) {
            if (!f[x].son[0]) op.push_back(operation(x+2e8,f[x].son[0]));
            f[x].son[0]=cover_(f[x].son[0],l,mid,lpos,rpos);
        }
        if (mid<rpos) {
            if (!f[x].son[1]) op.push_back(operation(x+3e8,f[x].son[1]));
            f[x].son[1]=cover_(f[x].son[1],mid+1,r,lpos,rpos);
        }
        pushup_(x,l,r);
        return x;
    }
    pair<long long,long long> check_prefix_(int x,long long l,long long r,long long lpos,int kl) {
        if (!x&&r-max(lpos,l)+1<kl) return make_pair(1e18+7,r-max(lpos,l)+1);
        if (!x) return make_pair(max(lpos,l)+kl-1,0);
        if (f[x].cnt==0) return make_pair(1e18+7,0);
        if (lpos<=l&&f[x].cnt<kl) return make_pair(1e18+7,f[x].cnt);
        if (l==r) return make_pair(l,0);
        long long mid=(l+r)>>1;
        if (lpos>mid) return check_prefix_(f[x].son[1],mid+1,r,lpos,kl);
        auto e=check_prefix_(f[x].son[0],l,mid,lpos,kl);
        if (e.first==1e18+7) {
            auto o=check_prefix_(f[x].son[1],mid+1,r,lpos,kl-e.second);
            if (o.first==1e18+7) return make_pair(1e18+7,e.second+o.second);
            return o;
        }
        return e;
    }
    int check_sum_(int x,long long l,long long r,long long lpos,long long rpos) {
        if (!x) return 0;
        if (f[x].cnt==0) {
            lpos=max(lpos,l), rpos=min(rpos,r);
            return (lpos+rpos)%mod*((rpos-lpos+1)%mod)%mod*inv%mod;
        }
        if (lpos<=l&&r<=rpos) return f[x].sum;
        int ans=0;
        long long mid=(l+r)>>1;
        if (lpos<=mid) ans=(ans+check_sum_(f[x].son[0],l,mid,lpos,rpos))%mod;
        if (mid<rpos) ans=(ans+check_sum_(f[x].son[1],mid+1,r,lpos,rpos))%mod;
        return ans;
    }
    pair<int,int> check_ver_() { return pair<int,int> (op.size(),cnt);}
    void rollback_(pair<int,int> ver) {
        while ((int)op.size()>ver.first) {
            operation e=op[(int)op.size()-1]; op.pop_back();
            if (e.x<=1e8) f[e.x].sum=e.vl;
            else if (e.x<=2e8) f[e.x-(int)1e8].cnt=e.vl;
            else if (e.x<=3e8) f[e.x-(int)2e8].son[0]=e.vl;
            else f[e.x-(int)3e8].son[1]=e.vl;
        }
        cnt=ver.second;
    }
} sst;
struct First_Segment_Tree {
    struct node { vector<pair<long long,int> > op;} f[400010];
    void insert_(int k,int l,int r,int lpos,int rpos,pair<long long,int> key) {
        if (key.second==0) return;
        if (lpos<=l&&r<=rpos) { f[k].op.push_back(key); return;}
        int mid=(l+r)>>1;
        if (lpos<=mid) insert_(k<<1,l,mid,lpos,rpos,key);
        if (mid<rpos) insert_(k<<1|1,mid+1,r,lpos,rpos,key);
    }
    void solve_(int k,int l,int r) {
        pair<int,int> ver=sst.check_ver_();
        for (auto o : f[k].op) {
            long long lr=sst.check_prefix_(ro,0,inf,o.first,o.second).first;
            ro=sst.cover_(ro,0,inf,o.first,lr);
        }
        maxn=max(maxn,(int)sst.op.size());
        if (l==r) { ans[l]=sst.check_sum_(ro,0,inf,0,inf), sst.rollback_(ver); return;}
        int mid=(l+r)>>1;
        solve_(k<<1,l,mid), solve_(k<<1|1,mid+1,r);
        sst.rollback_(ver);
    }
} fst;
int main() {
//    freopen("in.in","r",stdin);
//    freopen("out.out","w",stdout);

    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%lld %d\n",&op[i].first,&op[i].second);

    for (int i=1;i<=n;i++) {
        if (mp.count(op[i].first)) fst.insert_(1,1,n,mp[op[i].first].first,i-1,pair<long long,int> (op[i].first,mp[op[i].first].second));
        mp[op[i].first]=pair<int,int> (i,op[i].second);
    }
    for (int i=1;i<=n;i++) if (mp.count(op[i].first)) fst.insert_(1,1,n,mp[op[i].first].first,n,pair<long long,int> (op[i].first,mp[op[i].first].second)), mp.erase(op[i].first);

    ro=sst.cover_(ro,0,inf,0,0), fst.solve_(1,1,n);

    for (int i=1;i<=n;i++) printf("%d\n",ans[i]);

    fprintf(stderr,"%.10lf\n",clock()/1.0/CLOCKS_PER_SEC);
    fprintf(stderr,"%.10lf\n",1.0*maxn*sizeof(Second_Segment_Tree:: operation)/1048576.0);
    fprintf(stderr,"%.10lf\n",sizeof(sst)/1048576.0);
    return 0;
}