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 java.util.*;
import java.io.*;

public class Main {
    static ArrayList<Integer> [] adj;
    static boolean [] vis;
    static int left; static int right;
    static int edges;
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int n = sc.nextInt();
        adj = new ArrayList[200001];
        for (int i = 1; i <= 200000; i++) adj[i] = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = sc.nextInt(); int y = sc.nextInt();
            adj[x].add(y + 100000);
            adj[y + 100000].add(x);
        }
        vis = new boolean[200001];
        long res = 0;
        for (int i = 1; i <= 200000; i++) {
            if (!vis[i]) {
                left = 0; right = 0; edges = 0;
                dfs(i, -1);
                res = res + ((long) right * left);
            }
        }
        out.println(res - n);
        out.close();
    }

    static void dfs(int cur, int par) {
        if (cur <= 100000) left++; else right++;
        vis[cur] = true;
        for (Integer next: adj[cur]) {
            if (next == par) continue;
            else if (vis[next]) edges++;
            else {
                edges++;
                dfs(next, cur);
            }
        }
    }


    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }


    }

}