import sys
from collections import deque

def main():
    sys.setrecursionlimit(1 << 25)
    n = int(sys.stdin.readline())
    if n == 1:
        print(1)
        return

    edges = [[] for _ in range(n + 1)]
    for _ in range(n - 1):
        v, w = map(int, sys.stdin.readline().split())
        edges[v].append(w)
        edges[w].append(v)

    # Build children structure using BFS
    children = [[] for _ in range(n + 1)]
    parent = [0] * (n + 1)
    q = deque()
    q.append(1)
    parent[1] = -1  # mark root's parent

    while q:
        u = q.popleft()
        for v in edges[u]:
            if parent[v] == 0 and v != parent[u]:
                parent[v] = u
                children[u].append(v)
                q.append(v)

    # Compute subtree sizes using iterative post-order DFS
    subtree_size = [0] * (n + 1)
    stack = [(1, False)]

    while stack:
        node, visited = stack.pop()
        if not visited:
            stack.append((node, True))
            # Push children in reverse order to process them in the original order
            for child in reversed(children[node]):
                stack.append((child, False))
        else:
            size = 1
            for child in children[node]:
                size += subtree_size[child]
            subtree_size[node] = size

    # Compute answers
    for k in range(1, n + 1):
        sum_sq = 0
        for child in children[k]:
            sum_sq += subtree_size[child] ** 2
        ans = subtree_size[k] ** 2 - sum_sq
        print(ans)

if __name__ == '__main__':
    main()