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.
MAXN = 2 * 10 ** 5 + 10

n = int(input())
sz = [0] * (MAXN + 1)
fa = [0] * (MAXN + 1)
f = [0] * (MAXN + 1)
S = 0
sum = [0] * (MAXN + 1)
E = [[] for _ in range(MAXN + 1)]

def dfs(u, fr):
    global S
    sz[u] = 1
    fa[u] = fr
    for v in E[u]:
        if v != fr:
            dfs(v, u)
            f[u] += 1 * sz[u] * sz[v]
            sz[u] += sz[v]
            sum[u] += sum[v]
    sum[u] += f[u] * sz[u]
    S += f[u]

for _ in range(n - 1):
    u, v = map(int, input().split())
    E[u].append(v)
    E[v].append(u)

dfs(1, 0)
S *= S
for i in range(1, n + 1):
    S -= f[i] * f[i]
for u in range(1, n + 1):
    for v in E[u]:
        if v != fa[u]:
            S -= 2 * (sz[u] - sz[v]) * sum[v]

print(S)
