Heidi has finally found the mythical Tree of Life – a legendary combinatorial structure which is said to contain a prophecy crucially needed to defeat the undead armies.

On the surface, the Tree of Life is just a regular undirected tree well-known from computer science. This means that it is a collection of n points (called vertices), some of which are connected using n - 1 line segments (edges) so that each pair of vertices is connected by a path (a sequence of one or more edges).

To decipher the prophecy, Heidi needs to perform a number of steps. The first is counting the number of lifelines in the tree – these are paths of length 2, i.e., consisting of two edges. Help her!

Input

The first line of the input contains a single integer n – the number of vertices in the tree (1 ≤ n ≤ 10000). The vertices are labeled with the numbers from 1 to n. Then n - 1 lines follow, each describing one edge using two space-separated numbers a b – the labels of the vertices connected by the edge (1 ≤ a < b ≤ n). It is guaranteed that the input represents a tree.

Output

Print one integer – the number of lifelines in the tree.

Examples

Input

4
1 2
1 3
1 4


Output

3

Input

5
1 2
2 3
3 4
3 5


Output

4

Note

In the second sample, there are four lifelines: paths between vertices 1 and 3, 2 and 4, 2 and 5, and 4 and 5.
import java.io.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
    private static BufferedReader br;
    private static StringTokenizer st;
    private static PrintWriter pw;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int N = readInt();
        Graph graph = new Graph(N);
        for (int i = 0; i < N - 1; i++)
            graph.addEdge(readInt() - 1, readInt() - 1);

        pw.println(graph.countLifeLine());
        pw.close();
    }


    private static void exitImmediately() {
        pw.close();
        System.exit(0);
    }

    private static long readLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private static double readDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private static int readInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private static String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
//            if (!br.ready()) {
//                exitImmediately();
//            }
            st = new StringTokenizer(br.readLine().trim());
        }
        return st.nextToken();
    }
}

/*
    Nodes should be numbered [0...N-1]
    This is for un-directed graph.
 */
class Graph {

    static int[] FIB = new int[10010];

    static {
        // not really a standard fib, but w/e
        FIB[0] = FIB[1] = 0;
        FIB[2] = 1;
        for (int i = 3; i <= 10000; i++)
            FIB[i] = FIB[i - 1] + i - 1;
    }

    int N; // the total number of nodes
    ArrayList<List<Integer>> adj;


    public Graph(int N) {
        this.N = N;
        adj = new ArrayList<>();
        for (int i = 0; i < N; i++)
            adj.add(i, new ArrayList<>());
    }

    public void addEdge(int x, int y) {
        adj.get(x).add(y);
        adj.get(y).add(x);
    }

    public int countLifeLine() {
        int ans = 0;
        Queue<Integer> queue = new LinkedList<>();
        queue.add(0);
        queue.add(0);
        boolean[] visited = new boolean[N];
        visited[0] = true;

        while (!queue.isEmpty()) {
            int node = queue.remove();
            int depth = queue.remove();

            int numChild = 0;
            for (int next : adj.get(node)) {
                if (visited[next]) continue;
                numChild++;
            }

            switch (numChild) {
                case 0: // leaf
                    ans += depth - 1;
                    break;
                case 1: // a regular path
                    break;
                default: // diverging path

                    if (depth > 1) { // cut the tree from one above
                        ans += depth - 1;
                        depth = 1;
                    }
                    ans += FIB[numChild];
            }

            for (int next : adj.get(node)) {
                if (visited[next]) continue;
                visited[next] = true;
                queue.add(next);
                queue.add(depth + 1);
            }

        }

        return ans;
    }


}