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.
N = int(input())
MX = 100005

g = [[] for _ in range(MX)]
sz = [0] * MX

ans = 0

def dfs(v, p):
    global ans  # Use the global keyword to access the global 'ans' variable
    for u in g[v]:
        if u == p:
            continue
        dfs(u, v)
        sz[v] += sz[u]
    sz[v] += 1

    ways = sz[v] * (sz[v] - 1) // 2
    sum_ = 0
    for u in g[v]:
        if u == p:
            continue
        ways -= sz[u] * (sz[u] - 1) // 2

    ans += ways * ways
    ans += 2 * (N - sz[v]) * sz[v] * ways

def main():
    global N, ans
    
    for _ in range(N - 1):
        u, v = map(int, input().split())
        g[u].append(v)
        g[v].append(u)

    dfs(1, 0)

    ans = (N * (N - 1) // 2) * (N * (N - 1) // 2) - ans

    print(ans)

if __name__ == "__main__":
    main()
