#include <vector>
#include <queue>
#include <list>
#include <iostream>
#include <array>
#include <string>
#include <numeric>
#include <algorithm>
#include <cmath>

using namespace std;

using ll = long long;

struct Constell
{
    int id;
    ll size;
    ll sumx, sumy, sumx2, sumy2;
    
    Constell(pair<ll, ll> xy, int id) : id(id)
    {
        size = 1;
        sumx = xy.first;
        sumy = xy.second;
        sumx2 = sumx * sumx;
        sumy2 = sumy * sumy;
    }
    
    Constell()
    {}
};

struct ConstP
{
    int id1, id2;
    ll dist, prod;
    
    ConstP(Constell a, Constell b)
    {
        id1 = max(a.id, b.id);
        id2 = min(a.id, b.id);
        //d(A, B) = sum (a1-b1)^2 + (a2-b2)^2 over all a in A, b in B
        //|B|ai^2 - 2(sumA * sumB) + |A|bj^2
        dist = b.size * (a.sumx2 + a.sumy2) + a.size * (b.sumx2 + b.sumy2) - 2 * (a.sumx * b.sumx + a.sumy * b.sumy);
        prod = a.size * b.size;
    }
};

int cmp(ll n1, ll d1, ll n2, ll d2)
{
    //n1/d1 < n2/d2
    if (n1 * d2 < d1 * n2)
        return -1;
    if (n1 * d2 > d1 * n2)
        return 1;
    return 0;
}

bool operator<(ConstP b, ConstP a)
{
    int res = cmp(b.dist, b.prod, a.dist, a.prod);
    if (res == -1)
        return false;
    if (res == 1)
        return true;
    if (b.id1 < a.id1)
        return false;
    if (b.id1 > a.id1)
        return true;
    return b.id2 > a.id2;
}

Constell merge(Constell a, Constell b, int id)
{
    cout << a.size + b.size << '\n';
    Constell c;
    c.id = id;
    c.size = a.size + b.size;
    c.sumx = a.sumx + b.sumx;
    c.sumx2 = a.sumx2 + b.sumx2;
    c.sumy = a.sumy + b.sumy;
    c.sumy2 = a.sumy2 + b.sumy2;
    return c;
}

int main()
{
    int n;
    cin >> n;
    vector<Constell> constell(n);
    for (int i = 0; i < n; ++i)
    {
        ll x, y;
        cin >> x >> y;
        constell[i] = Constell({x, y}, i);
    }
    priority_queue<ConstP> pq;
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j)
            pq.push(ConstP(constell[i], constell[j]));
    while (!pq.empty())
    {
        ConstP p = pq.top();
        pq.pop();
        if (constell[p.id1].size == 0 || constell[p.id2].size == 0)
            continue;
        constell.push_back(merge(constell[p.id1], constell[p.id2], constell.size()));
        constell[p.id1].size = 0;
        constell[p.id2].size = 0;
        for (int i = 0; i + 1 < constell.size(); ++i)
        {
            if (constell[i].size == 0)
                continue;
            pq.push(ConstP(constell[i], constell.back()));
        }
    }
    return 0;
}