#include<bits/stdc++.h>
#define fff ios_base::sync_with_stdio(0);cin.tie(0)
#define _for(i,_) for(int i=0 ; i<_ ; i++)
#define _forr(i,_) for(int i=1 ; i<=_ ; i++)
#define _rof(i,_) for(int i=_-1 ; i>=0 ; i--)
#define _roff(i,_) for(int i=_ ; i>=1 ; i--)
#define NL cout << endl
#define SP cout << " "
#define pb push_back
#define pp pop_back
#define inf INT_MAX
#define BIG INT_MAX
#define INF 1e18
#define ss second
#define ff first
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> pl;
typedef vector<ll> vl;
typedef vector<ll> vl;
typedef pair<ll,ll> pii;
typedef vector<int> vi;
const ld PI = 3.14159265359;
const int mod = 1000000007;
const int MAX = 300009;

ll a[MAX], tree[MAX*5], lazy[MAX*5], n;
ll b[MAX] ,t, c[MAX];
map<ll,ll> ans;
pl p[MAX];

void build_tree(int node, int l, int r) {
    if(l > r)
        return;
    if(l == r)
    {
        tree[node] = 1;
    return;
  }
  build_tree(node*2, l, (l+r)/2);
  build_tree(node*2+1, 1+(l+r)/2, r);
  tree[node] = tree[node*2] + tree[node*2+1];
}

void update_tree(int node, int l, int r, int i, int j, int value)
{

  if(l > r || l > j || r < i) return;
  if(l >= i && r <= j)
  {
    tree[node] = value*(r-l+1);
    lazy[node] = value;
    // if(l != r)
    // {
    //   lazy[node*2] += value;
    //   lazy[node*2+1] += value;
    // }
    return;
  }

  if(lazy[node] != -1)
  {
    // tree[node] = lazy[node]*(j-i+1);
    if(l != r)
    {
      tree[node*2] = value*((r-l+2)/2);
      lazy[node*2] = value;

      lazy[node*2+1] = value;
      tree[node*2+1] = value*((r-l+1)/2);
    }
    lazy[node] = -1;
  }

  update_tree(node*2, l, (l+r)/2, i, j, value);
  update_tree(1+node*2, 1+(l+r)/2, r, i, j, value);
  tree[node] = tree[node*2] + tree[node*2+1];
}

ll query_tree(int node, int l, int r, int i, int j) {

  if(l > r || l > j || r < i)
      return 0;

  if(l >= i && r <= j) return tree[node];

  if(lazy[node] != -1)
  {
    // tree[node] = lazy[node]*(j-i+1);
    if(l != r)
    {
      tree[node*2] = lazy[node]*((r-l+1)/2 + (r-l+1)%2);
      lazy[node*2] = lazy[node];

      lazy[node*2+1] = lazy[node];
      tree[node*2+1] = lazy[node]*((r-l+1)/2);

      // lazy[node*2] = lazy[node];
      // lazy[node*2+1] = lazy[node];
    }
    lazy[node] = -1;
  }

  ll q1 = query_tree(node*2, l, (l+r)/2, i, j);
  ll q2 = query_tree(1+node*2, 1+(l+r)/2, r, i, j);
  ll res = q1 + q2;
  return res;
}

int main()
{
    fff;
    memset(lazy, -1, sizeof lazy);
    cin >> n;
    _for(i,n)
    {
        cin >> p[i].ff >> p[i].ss;
        b[i] = p[i].ff;
        c[i] = p[i].ff;
    }
    // build_tree(1, 0, n-1);
    sort(p, p+n);
    sort(b, b+n);
    _for(i,n)
    {
        ll u = upper_bound(b, b+n, b[i] + p[i].ss - 1) - b;
        p[i].ss = u - i;
    }
    for(int i=n ; i--;  )
    {

        ll sum = query_tree(1, 0, n-1, i, i + p[i].ss - 1);
        sum++;
        update_tree(1, 0, n-1, i, i + p[i].ss - 1, 0);
        update_tree(1, 0, n-1, i, i, sum);
        ans[p[i].ff] = sum;
        // cout << p[i].ff <<  " " << sum << endl;
    }
    _for(i,n)
        cout << ans[c[i]] << " ";
}