For a given set of two-dimensional points S, let's denote its extension E(S) as the result of the following algorithm:

Create another set of two-dimensional points R, which is initially equal to S. Then, while there exist four numbers x_1, y_1, x_2 and y_2 such that (x_1, y_1) ∈ R, (x_1, y_2) ∈ R, (x_2, y_1) ∈ R and (x_2, y_2) ∉ R, add (x_2, y_2) to R. When it is impossible to find such four integers, let R be the result of the algorithm.

Now for the problem itself. You are given a set of two-dimensional points S, which is initially empty. You have to process two types of queries: add some point to S, or remove some point from it. After each query you have to compute the size of E(S).

Input

The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.

Then q lines follow, each containing two integers x_i, y_i (1 ≤ x_i, y_i ≤ 3 ⋅ 10^5), denoting i-th query as follows: if (x_i, y_i) ∈ S, erase it from S, otherwise insert (x_i, y_i) into S.

Output

Print q integers. i-th integer should be equal to the size of E(S) after processing first i queries.

Example

Input


7
1 1
1 2
2 1
2 2
1 2
1 3
2 1


Output


1 2 4 4 4 6 3 
#include <bits/stdc++.h>
using namespace std;
const int N = 300050;
const int M = 2 * N;
struct DSU {
  int sz[M][2], p[M], cnt[M];
  long long sum;
  void init() {
    sum = 0;
    for (int i = 0; i < M; i++) p[i] = i, cnt[i] = 1, sz[i][i > N] = 1;
  }
  vector<int> bck;
  vector<long long> las;
  void del(int x) { sum -= (long long)sz[x][0] * sz[x][1]; }
  void add(int x) { sum += (long long)sz[x][0] * sz[x][1]; }
  int Find(int x) { return p[x] == x ? x : Find(p[x]); }
  void Union(int x, int y) {
    las.push_back(sum);
    x = Find(x);
    y = Find(y);
    if (x == y) {
      bck.push_back(0);
      return;
    }
    if (cnt[x] > cnt[y]) swap(x, y);
    del(x);
    del(y);
    p[x] = y;
    bck.push_back(x);
    cnt[y] += cnt[x];
    sz[y][0] += sz[x][0];
    sz[y][1] += sz[x][1];
    add(y);
  }
  void Undo() {
    sum = las.back();
    las.pop_back();
    int i = bck.back();
    bck.pop_back();
    if (i) {
      cnt[p[i]] -= cnt[i];
      sz[p[i]][0] -= sz[i][0];
      sz[p[i]][1] -= sz[i][1];
      p[i] = i;
    }
  }
} DS;
vector<pair<int, int>> E[M];
int ls[M], rs[M], tsz, root;
void Set(int &c, int ss, int se, int qs, int qe, int x, int y) {
  if (qs > qe || qs > se || ss > qe) return;
  if (!c) c = ++tsz;
  if (qs <= ss && qe >= se) {
    E[c].push_back({x, y + N});
    return;
  }
  int mid = ss + se >> 1;
  Set(ls[c], ss, mid, qs, qe, x, y);
  Set(rs[c], mid + 1, se, qs, qe, x, y);
}
void Solve(int c, int ss, int se) {
  for (auto p : E[c]) DS.Union(p.first, p.second);
  if (ss == se) {
    printf("%lld ", DS.sum);
  } else {
    int mid = ss + se >> 1;
    Solve(ls[c], ss, mid);
    Solve(rs[c], mid + 1, se);
  }
  for (auto p : E[c]) DS.Undo();
}
int main() {
  DS.init();
  int q;
  scanf("%i", &q);
  map<pair<int, int>, int> tme;
  for (int i = 1, x, y; i <= q; i++) {
    scanf("%i %i", &x, &y);
    if (tme.count({x, y}))
      Set(root, 1, q, tme[{x, y}], i - 1, x, y), tme.erase({x, y});
    else
      tme[{x, y}] = i;
  }
  for (auto it : tme)
    Set(root, 1, q, it.second, q, it.first.first, it.first.second);
  Solve(root, 1, q);
  return 0;
}
