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.
from collections import defaultdict

def dfs(u, pa):
    sc[u] = 1
    s = 0
    res1 = 0
    res2 = 0
    for v in a[u]:
        if v != pa:
            dfs(v, u)
            sc[u] += sc[v]
            s += sc[v] * (sc[v] - 1) // 2
            res1 += dp[v]
    p[u] = s

    for v in a[u]:
        if v != pa:
            tv = (sc[v] * (sc[v] - 1) // 2)
            res1 += ((sc[u] - sc[v]) * (sc[u] - sc[v] - 1) // 2) * tv + (p[v] + f[v]) * (sc[u] - sc[v])
            res2 += (s - tv) * tv
            f[u] += f[v] + sc[v] * (s - tv) + p[v]

    res1 -= (res2 // 2)
    dp[u] = res1

def giai():
    dfs(1, 1)
    print(dp[1] * 2)

if __name__ == "__main__":
    n = int(input())
    a = defaultdict(list)
    sc = [0] * (n + 1)
    dp = [0] * (n + 1)
    f = [0] * (n + 1)
    p = [0] * (n + 1)

    for _ in range(n - 1):
        x, y = map(int, input().split())
        a[x].append(y)
        a[y].append(x)

    giai()
