#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct Frac {
    ll p, q;
    bool inline operator < (const Frac &rhs) const {
        return p * rhs.q < q * rhs.p;
    }
};

struct Pair {
    Frac dist; int i, j;
    Pair(Frac dist, int _i, int _j): dist(dist), i(_i), j(_j) {
        if (i > j) swap(i, j);
    }
    bool inline operator < (const Pair &rhs) const {
        return make_tuple(dist, i, j) < make_tuple(rhs.dist, rhs.i, rhs.j);
    }
};

struct Group {
    ll x2, x, y2, y;
    int id, sz;
};

Group merge(Group &a, Group &b, int id) {
    return {
        a.x2 + b.x2,
        a.x + b.x,
        a.y2 + b.y2,
        a.y + b.y,
        id,
        a.sz + b.sz,
    };
}

Frac getDist(Group &a, Group &b) {
    ll dx = b.sz * a.x2 + a.sz * b.x2 - 2 * a.x * b.x;
    ll dy = b.sz * a.y2 + a.sz * b.y2 - 2 * a.y * b.y;
    return {dx + dy, a.sz * b.sz};
}

int main() {
    int n;
    vector<Group> group;

    cin >> n;
    for(int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        group.push_back({x*x, x, y*y, y, i, 1});
    }

    auto getPair = [&](int i, int j) {
        Frac dist = getDist(group[i], group[j]);
        return Pair(dist, i, j);
    };

    set<Pair> s;
    for(int i = 0; i < n; ++i) {
        for(int j = i+1; j < n; ++j) {
            s.insert(getPair(i, j));
        }
    }

    vector<bool> active(n, true);

    while (!s.empty()) {
        // for(auto [dist, i, j]: s) printf("dist, i, j: (%lld, %lld) %d %d\n", dist.p, dist.q, i, j);
        int p0 = s.begin()->i, p1 = s.begin()->j; s.erase(s.begin());
        int n = group.size();

        active[p0] = false;
        active[p1] = false;
        for(int i = 0; i < n; ++i) {
            if (active[i]) {
                Pair c1 = getPair(i, p0);
                Pair c2 = getPair(i, p1);
                // printf("dist, i, p0: %lld %lld %d %d\n", c1.dist.p, c1.dist.q, c1.i, c1.j);
                // printf("dist, i, p1: %lld %lld %d %d\n", c2.dist.p, c2.dist.q, c2.i, c2.j);
                s.erase(c1);
                s.erase(c2);
            }
        }

        group.push_back(merge(group[p0], group[p1], n));
        printf("%d\n", group[n].sz);
        active.push_back(true);
        for(int i = 0; i < n; ++i) {
            if (active[i]) {
                s.insert(getPair(i, n));
            }
        }
    }

    return 0;
}