There are N dots in a two-dimensional plane. The coordinates of the i-th dot are (x_i, y_i).

We will repeat the following operation as long as possible:

* Choose four integers a, b, c, d (a \neq c, b \neq d) such that there are dots at exactly three of the positions (a, b), (a, d), (c, b) and (c, d), and add a dot at the remaining position.



We can prove that we can only do this operation a finite number of times. Find the maximum number of times we can do the operation.

Constraints

* 1 \leq N \leq 10^5
* 1 \leq x_i, y_i \leq 10^5
* If i \neq j, x_i \neq x_j or y_i \neq y_j.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N
x_1 y_1
:
x_N y_N


Output

Print the maximum number of times we can do the operation.

Examples

Input

3
1 1
5 1
5 5


Output

1


Input

2
10 10
20 20


Output

0


Input

9
1 1
2 1
3 1
4 1
5 1
1 2
1 3
1 4
1 5


Output

16
class UnionFind:
    # 初期化
    def __init__(self, n):
        # 根なら-size, 子なら親の頂点
        self.par = [-1] * n
        # 木の高さ
        self.rank = [0] * n

    # 検索
    def find(self, x):
        if self.par[x] < 0:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    # 併合
    def unite(self, x, y):
        x = self.find(x)
        y = self.find(y)
        # 異なる集合に属する場合のみ併合
        if x != y:
            # 高い方をxとする。
            if self.rank[x] < self.rank[y]:
                x,y = y,x
            # 同じ高さの時は高さ+1
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            # yの親をxとし、xのサイズにyのサイズを加える
            self.par[x] += self.par[y]
            self.par[y] = x

    # 同集合判定
    def same(self, x, y):
        return self.find(x) == self.find(y)

    # 集合の大きさ
    def size(self, x):
        return -self.par[self.find(x)]


import operator

n = int(input())
z = [list(map(int, input().split())) for i in range(n)]

for i in range(n):
    z[i].append(i)

u = UnionFind(n)
z.sort()
for i in range(1,n):
    if z[i][0]==z[i-1][0]:
        u.unite(z[i][2],z[i-1][2])

z.sort(key=operator.itemgetter(1))
for i in range(1,n):
    if z[i][1]==z[i-1][1]:
        u.unite(z[i][2],z[i-1][2])

l = [[]for i in range(n)]

z.sort(key=operator.itemgetter(2))
for i in range(n):
    l[u.find(i)].append(z[i])

ans = 0
for i in range(n):
    if l[i]!=[]:
        x = set()
        y = set()
        for a in l[i]:
            if a[0] not in x:
                x.add(a[0])
            if a[1] not in y:
                y.add(a[1])
        ans += len(x)*len(y)-len(l[i])
print(ans)
