#include <bits/stdc++.h>

using namespace std;


typedef long long ll;


#include <cassert>


namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
  public:
    dsu() : _n(0) {}
    dsu(int n) : _n(n), parent_or_size(n, -1) {}

    int merge(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        int x = leader(a), y = leader(b);
        if (x == y) return x;
        if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
        parent_or_size[x] += parent_or_size[y];
        parent_or_size[y] = x;
        return x;
    }

    bool same(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        return leader(a) == leader(b);
    }

    int leader(int a) {
        assert(0 <= a && a < _n);
        if (parent_or_size[a] < 0) return a;
        return parent_or_size[a] = leader(parent_or_size[a]);
    }

    int size(int a) {
        assert(0 <= a && a < _n);
        return -parent_or_size[leader(a)];
    }

    std::vector<std::vector<int>> groups() {
        std::vector<int> leader_buf(_n), group_size(_n);
        for (int i = 0; i < _n; i++) {
            leader_buf[i] = leader(i);
            group_size[leader_buf[i]]++;
        }
        std::vector<std::vector<int>> result(_n);
        for (int i = 0; i < _n; i++) {
            result[i].reserve(group_size[i]);
        }
        for (int i = 0; i < _n; i++) {
            result[leader_buf[i]].push_back(i);
        }
        result.erase(
            std::remove_if(result.begin(), result.end(),
                           [&](const std::vector<int>& v) { return v.empty(); }),
            result.end());
        return result;
    }

  private:
    int _n;
    // root node: -1 * component size
    // otherwise: parent
    std::vector<int> parent_or_size;
};

}  // namespace atcoder

 

using namespace atcoder;


bool jud(pair<ll,ll> a,pair<ll,ll> b){
    bool flag=false;
    if(a.first<b.first&&a.second<b.second){
        flag=true;
    }
    if(a.first>b.first&&a.second>b.second){
        flag=true;
    }
    return flag;
}

int main() {

    int N;

    cin>>N;

    vector<pair<pair<int,int>,int> > vp;

    int x,y;

    for(int i=0;i<N;i++){
        cin>>x>>y;
        vp.emplace_back(make_pair(x,y),i);
    }

    sort(vp.begin(),vp.end(),[](pair<pair<int,int>,int> a,pair<pair<int,int>,int> b){
        return a.first.first<b.first.first;
    });
/*
    for(int i=0;i<N;i++){
        cout<<vp[i].first.first<<":"<<vp[i].first.second<<":"<<vp[i].second<<endl;
    }
*/
    set<pair<int,int> > st;  //(y,id)  yが最小かつ

    dsu d(N);
    for(int i=0;i<N;i++){

        int org=vp[i].first.second; 
        int id=vp[i].second;
        int l=org;

        //cout<<"org:"<<org<<" id:"<<id<<" l:"<<l<<endl;

        set<pair<int,int> >::iterator itr=st.begin();

        while(!st.empty()){
           // cout<<"judge: y:"<<itr->first<<" id:"<<itr->second<<endl;

        

            if(itr->first<org){
                l=min(l,itr->first);
                d.merge(itr->second,id);
               // cout<<"erase:y:"<<itr->first<<":id"<<itr->second<<endl;
                itr=st.erase(itr);
                //cout<<"l:"<<l<<endl;
            }else{
                break;
            }
        }
       // cout<<"add:y:"<<l<<" :id "<<id<<endl;
        st.emplace(l,id);
    }

    for(int i=0;i<N;i++){
        cout<<d.size(i)<<endl;
    }
    
}


Measured memory_bytes: 11044