#include <bits/stdc++.h>
using namespace std;
struct node{
         int mx;
};

struct seg_tree{
         vector<node> values;
         int sz = 1;
         void init(int n){
                  while(sz < n) sz *= 2;
                  values.resize(2 * sz, {-1});
         }
         node single(int v){
                  return {v};
         }
         node merge(node &a, node &b){
                  return {max(a.mx, b.mx)};
         }
         node neutral(){
                  return {-1};
         }
         void set(int i, int v, int x, int lx, int rx){
                  if(rx - lx == 1){
                           node rr = single(v);
                           values[x] = merge(values[x], rr);
                           return;
                  }
                  int m = (lx + rx) >> 1;
                  if(i < m)
                           set(i, v, 2 * x + 1, lx, m);
                  else
                           set(i, v, 2 * x + 2, m, rx);

                  values[x] = merge(values[2 * x + 1], values[2 * x + 2]);
         }
         void set(int i, int v){
                  set(i, v, 0, 0, sz);
         }
         node calc(int l, int r, int x, int lx, int rx){
                  if(l >= rx || lx >= r) return neutral();
                  if(lx >= l && rx <= r){
                           return values[x];
                  }
                  int m = (lx + rx) >> 1;
                  node s1 = calc(l, r, 2 * x + 1, lx, m);
                  node s2 = calc(l, r, 2 * x + 2, m, rx);
                  return merge(s1, s2);
         }
         node calc(int l, int r){
                  return calc(l, r, 0, 0, sz);
         }
};
int main() {
         cin.tie(0);cin.sync_with_stdio(0);
         cout.tie(0);cout.sync_with_stdio(0);

         int n;
         cin>>n;
         int L[n], R[n];
         vector<int> compress;
         for(int i = 0 ; i < n; i++){
                  int Li, ti;
                  cin>>Li>>ti;
                  L[i]= Li;
                  R[i]= Li + ti - 1;
                  compress.push_back(L[i]);
                  compress.push_back(R[i]);
         }

         sort(compress.begin(), compress.end());
         compress.erase(unique(compress.begin(), compress.end()), compress.end());

         map<int,int> mp;
         for(int i = 0; i < compress.size(); i++)
                  mp[compress[i]]= i + 1;

         seg_tree st;
         st.init(2 * n + 100);

         int I[n];
         iota(I, I + n, 0);
         sort(I, I + n, [&](int i, int j){
                  if(L[i] != L[j])
                           return L[i] < L[j];
                  return R[i] > R[j];
         });

         int ans[n];
         for(int i : I){
                  ans[i]= st.calc(R[i], 2 * n + 10).mx + 1;
                  st.set(R[i], ans[i]);
         }
         for(int i = 0; i < n; i++)
                  cout<<ans[i]<<" ";
}