#include <bits/stdc++.h>

 typedef long long LL;

 const int N = ;

 struct Node {

     int x, y;

     Node(int X, int Y) {

         x = X;

         y = Y;

     }

 };

 std::map<int, int> mp[N];

 int n, m;

 LL ans[N];

 std::vector<Node> v[N << ];

 namespace ufs {

     struct opt {

         int x, y;

         opt(){}

         opt(int X, int Y) {

             x = X, y = Y;

         }

     }stk[N * ]; int top;

     int fa[N * ], siz[N * ], s1[N * ], s2[N * ], clock;

     LL tot, stk2[N];

     inline void init() {

         for(int i = ; i < N; i++) {

             fa[i] = i;

             fa[i + N] = i + N;

             siz[i] = siz[i + N] = ;

             s1[i] = s2[i + N] = ;

             s2[i] = s1[i + N] = ;

         }

         top = clock = ;

         return;

     }

     int find(int x) {

         if(x == fa[x]) return x;

         return find(fa[x]);

     }

     inline LL cal(int x) {

         return 1ll * s1[x] * s2[x];

     }

     inline void merge(int x, int y) {

         x = find(x);

         y = find(y);

         if(x == y) return;

         if(siz[x] < siz[y]) {

             std::swap(x, y);

         }

         stk2[++clock] = tot;

         tot -= cal(x) + cal(y);

         stk[++top] = opt(y, fa[y]);

         fa[y] = x;

         stk[++top] = opt(x, siz[x]);

         siz[x] += siz[y];

         stk[++top] = opt(x, s1[x]);

         s1[x] += s1[y];

         stk[++top] = opt(x, s2[x]);

         s2[x] += s2[y];

         tot += cal(x);

         return;

     }

     inline void erase(int t) {

         while(clock > t) {

             tot = stk2[clock--];

             s2[stk[top].x] = stk[top].y;

             top--;

             s1[stk[top].x] = stk[top].y;

             top--;

             siz[stk[top].x] = stk[top].y;

             top--;

             fa[stk[top].x] = stk[top].y;

             top--;

         }

         return;

     }

 }

 void add(int L, int R, Node x, int l, int r, int o) {

     if(L <= l && r <= R) {

         v[o].push_back(x);

         return;

     }

     int mid = (l + r) >> ;

     if(L <= mid) {

         add(L, R, x, l, mid, o << );

     }

     if(mid < R) {

         add(L, R, x, mid + , r, o <<  | );

     }

     return;

 }

 void solve(int l, int r, int o) {

     int now = ufs::clock;

     for(int i = ; i < (int)v[o].size(); i++) {

         ufs::merge(v[o][i].x, v[o][i].y + N);

         //printf("[%d %d] merge %d %d \n", l, r, v[o][i].x, v[o][i].y);

     }

     if(l == r) {

         ans[r] = ufs::tot;

         ufs::erase(now);

         return;

     }

     int mid = (l + r) >> ;

     solve(l, mid, o << );

     solve(mid + , r, o <<  | );

     ufs::erase(now);

     return;

 }

 int main() {

     ufs::init();

     scanf("%d", &n);

     for(int i = , x, y; i <= n; i++) {

         scanf("%d%d", &x, &y);

         if(mp[x][y]) {

             add(mp[x][y], i - , Node(x, y), , n, );

             //printf("add : (%d %d) [%d %d] \n", x, y, mp[x][y], i - 1);

             mp[x][y] = ;

         }

         else {

             mp[x][y] = i;

         }

     }

     std::map<int, int>::iterator it;

     for(int i = ; i < N; i++) {

         for(it = mp[i].begin(); it != mp[i].end(); it++) {

             if(it->second) {

                 add(it->second, n, Node(i, it->first), , n, );

                 //printf("add : (%d %d) [%d %d] \n", i, it->first, it->second, n);

             }

         }

     }

     solve(, n, );

     for(int i = ; i <= n; i++) {

         printf("%lld ", ans[i]);

     }

     return ;

 }