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
import sys
input=sys.stdin.readline
from collections import defaultdict
class UnionFind:
    def __init__(self,n):
        self.par=[i for i in range(n)]
        self.rank=[0]*n
    def find(self,x):
        if self.par[x]==x:
            return x
        else:
            self.par[x]=self.find(self.par[x])
            return self.par[x]
    def union(self,x,y):
        x=self.find(x)
        y=self.find(y)
        if x==y:
            return
        if self.rank[x]<self.rank[y]:
            self.par[x]=y
        else:
            self.par[y]=x
            if self.rank[x]==self.rank[y]:
                self.rank[x]+=1
    def same_check(self,x,y):
        return self.find(x)==self.find(y)

n=int(input())
uf=UnionFind(n)
XY=[tuple(map(int,input().split())) for _ in range(n)]
Xd=defaultdict(list)
Yd=defaultdict(list)
for i,(x,y) in enumerate(XY):
    Xd[x].append(i)
    Yd[y].append(i)
for x in Xd:
    i=Xd[x][0]
    for j in Xd[x]:
        uf.union(i,j)
for y in Yd:
    i=Yd[y][0]
    for j in Yd[y]:
        uf.union(i,j)
d=defaultdict(list)
for i in range(n):
    d[uf.find(i)].append(i)
ans=0
for k in d:
    Xs,Ys=set(),set()
    for i in d[k]:
        x,y=XY[i]
        Xs.add(x); Ys.add(y)
    ans+=len(Xs)*len(Ys)
ans-=n
print(ans)