#include <iostream>
#include <vector>
#include <assert.h>

using namespace std;

static const int MAX_N = 32000;
int tree[MAX_N * 4];

struct segment_tree {

    using vref = const vector<int> &;

    explicit segment_tree(vref arr): n(int(arr.size())) {
        build_(arr, 1, 0, n - 1);
    }

    int sum(int l, int r) {
        return sum_(1, 0, n - 1, l, r);
    }

    void add(int pos, int val) {
        add_(1, 0, n - 1, pos, val);
    }

private:

    int sum_(int v, int tl, int tr, int l, int r) {
        if (l > r) {
            return 0;
        }
        if (tl == l && tr == r) {
            return tree[v];
        }
        int m = (tl + tr) / 2;
        int left_sum = sum_(v * 2, tl, m, l, min(r, m));
        int right_sum = sum_(v * 2 + 1, m + 1, tr, max(l, m + 1), r);
        return left_sum + right_sum;
    }

    void build_(vref arr, int v, int tl, int tr) {
        if (tl == tr) {
            tree[v] = arr[tl];
        } else {
            int m = (tl + tr) / 2;
            build_(arr, v * 2, tl, m);
            build_(arr, v * 2 + 1, m + 1, tr);
            tree[v] = tree[v * 2] + tree[v * 2 + 1];
        }
    }

    void add_(int v, int tl, int tr, int pos, int val) {
        if (tl == tr) {
            tree[v] += val;
        } else {
            int m = (tl + tr) / 2;
            if (pos <= m) {
                add_(2 * v, tl, m, pos, val);
            } else {
                add_(2 * v + 1, m + 1, tr, pos, val);
            }
            tree[v] = tree[2 * v] + tree[2 * v + 1];
        }
    }
    int n;
};


void segment_tree_test() {
    vector<int> a = {1,1,1,1,1,1};
    segment_tree t{a};
    assert(t.sum(0, 5) == 6);
    t.add(2, 1);
    assert(t.sum(0, 5) == 7);
    assert(t.sum(2, 2) == 2);

    segment_tree t2{{100}};
    assert(t2.sum(0, 0) == 100);
    t2.add(0, -50);
    assert(t2.sum(0, 0) == 50);

}

int main() {

    ios_base::sync_with_stdio(0); // отключение синхронизации с printf,scanf
    cin.tie(0); // отключение синхронизации с cout

    while (true) {
        int n; cin >> n;
        vector<int> arr(32000);
        segment_tree t(arr);
        vector<int> levels(n);
        for (int i = 0; i < n; ++i) {
            int x, y; cin >> x >> y;
            t.add(x, 1);
            int level = t.sum(0, x) - 1;
            ++levels[level];
        }

        for (int j = 0; j < levels.size(); ++j) {
            cout << levels[j];
            if (j < levels.size() - 1) {
                cout << '\n';
            }
        }

        if (cin.eof()) {
            break;
        }

        cout << '\n';
    }

    return 0;
}