# include <bits/stdc++.h>
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;
        long long cnt;
        friend bool operator != (node x,node y) { return x.son[0]!=y.son[0]||x.son[1]!=y.son[1]||x.sum!=y.sum||x.cnt!=y.cnt;}
    } f[10000010];
    struct operation {
        int x,opt;
        long long vl;
        operation() {}
        operation(int _x,int _opt,long long _vl) { x=_x, opt=_opt, vl=_vl;}
    };
    vector<operation> op;
    void pushup_(int x) { 
        op.push_back(operation(x,1,f[x].sum)), f[x].sum=(f[f[x].son[0]].sum+f[f[x].son[1]].sum)%mod;
        op.push_back(operation(x,2,f[x].cnt)), f[x].cnt=f[f[x].son[0]].cnt+f[f[x].son[1]].cnt;
    }
    int cover_(int x,long long l,long long r,long long lpos,long long rpos) {
        if (!x) x=++cnt;
        if (f[x].cnt==r-l+1) return x;
        if (lpos<=l&&r<=rpos) {
            op.push_back(operation(x,1,f[x].sum)), f[x].sum=(l+r)%mod*((r-l+1)%mod)%mod*inv%mod;
            op.push_back(operation(x,2,f[x].cnt)), f[x].cnt=r-l+1;
            return x;
        }
        long long mid=(l+r)>>1;
        if (lpos<=mid) op.push_back(operation(x,3,f[x].son[0])), f[x].son[0]=cover_(f[x].son[0],l,mid,lpos,rpos);
        if (mid<rpos) op.push_back(operation(x,4,f[x].son[1])), f[x].son[1]=cover_(f[x].son[1],mid+1,r,lpos,rpos);
        pushup_(x);
        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==r-l+1) return make_pair(1e18+7,0);
        if (lpos<=l&&r-l+1-f[x].cnt<kl) return make_pair(1e18+7,r-l+1-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==r-l+1) {
            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.opt==1) f[e.x].sum=e.vl;
            if (e.opt==2) f[e.x].cnt=e.vl;
            if (e.opt==3) f[e.x].son[0]=e.vl;
            if (e.opt==4) f[e.x].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);
        }
        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]);

    return 0;
}