Little penguin Polo has got a tree — a non-directed connected acyclic graph, containing *n* nodes and *n* - 1 edges. We will consider the tree nodes numbered by integers from 1 to *n*.

Today Polo wonders, how to find the number of pairs of paths that don't have common nodes. More formally, he should find the number of groups of four integers *a*, *b*, *c* and *d* such that:
 -  1 ≤ *a* &lt; *b* ≤ *n*; -  1 ≤ *c* &lt; *d* ≤ *n*; -  there's no such node that lies on both the shortest path from node *a* to node *b* and from node *c* to node *d*. 
The shortest path betweem two nodes is the path that is shortest in the number of edges.

Help Polo solve this problem.
The first line contains integer *n* (1 ≤ *n* ≤ 80000) — the number of tree nodes. Each of the following *n* - 1 lines contains a pair of integers *u*<sub class="lower-index">*i*</sub> and *v*<sub class="lower-index">*i*</sub> (1 ≤ *u*<sub class="lower-index">*i*</sub>, *v*<sub class="lower-index">*i*</sub> ≤ *n*; *u*<sub class="lower-index">*i*</sub> ≠ *v*<sub class="lower-index">*i*</sub>) — the *i*-th edge of the tree.

It is guaranteed that the given graph is a tree.
def get():
    line = input()
    return map(int, line.split())

def dfs(v):
    global ans
    temp, op = last[v], 0
    used[v] = True
    a[v] = 1

    while temp != 0:
        k = end[temp]
        while used[k] and temp != 0:
            temp = nxt[temp]
            k = end[temp]
        
        if not temp:
            break

        dfs(k)
        op += a[v] * a[k]
        a[v] += a[k]

    ans -= op * (op + 2 * a[v] * (n - a[v]))

n = int(input())
tot = 0
last = [0] * 200005
nxt = [0] * 200005
end = [0] * 200005
a = [0] * 80005
used = [False] * 80005

for _ in range(1, n):
    x, y = get()
    tot += 1
    end[tot] = y
    nxt[tot] = last[x]
    last[x] = tot
    tot += 1
    end[tot] = x
    nxt[tot] = last[y]
    last[y] = tot

ans = (n * (n - 1)) >> 1
ans = ans * ans
dfs(1)
print(ans)
