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.
//package com.company;

import java.util.Scanner;
import java.util.Vector;

public class Main {

    public static void main(String[] args) {
	    Solve solve = new Solve(new Scanner(System.in));

        solve.run();
    }


}
class Solve {
    private final Scanner SCANNER;
    private static final int SIZE = 10000 + 99;
    private int []color = new int[SIZE];
    private int []par = new int[SIZE];
    private Vector<Integer>mat[] = new Vector[SIZE];
    private int N , M;

    public Solve(Scanner scanner){
        this.SCANNER = scanner;
    }

    public void run(){

        int u , v ;


        N = SCANNER.nextInt();
        for (int i = 0 ; i <= N ; ++i){
            mat[i] = new Vector<>();
            par[i] = i;

        }
        for(int i = 1 ; i < N ; ++i){
            u = SCANNER.nextInt();
            v = SCANNER.nextInt();
            mat[u].add(v);
            mat[v].add(u);
        }

        DFS(1);
        int ans = 0;
        int ar[] = new int[N+9];
        for(int i = 2 ; i <= N ; ++i){
            ar[par[i]]++;
        }
        for(int i = 0 ; i <= N ; ++i){
            if(par[par[i]] != par[i] ){
                ans++;
            }
        }
        int ans2 = 0 ;
        for(int i = 1 ; i <= N  ; ++i){
            ans2 += ( (ar[i]*(ar[i]-1)) / 2 );
        }
        ans += ans2;
        System.out.print(ans);
    }

    final static int WHITE  = 0;
    final static int GRAY   = 1;
    final static int BLACK  = 2;

    int dx[] = {1 , -1 , 0 , 0 };
    int dy[] = { 0 , 0 , 1 , -1};
    private void DFS(int node){
        color[node] = BLACK;
        for(int i = 0 ; i < mat[node].size() ; ++i){
            int cur = mat[node].get(i);
            if(color[cur] != WHITE){
                continue;
            }else{
                par[cur] = node;
                DFS(cur);
            }

        }
    }


}
