### BUGGY CODE ###

def main():

    n = int(input())
    ab = [list(map(int, input().split())) for _ in [0]*(n-1)]

    g = [[] for _ in [0]*n]
    [g[a-1].append(b-1) for a, b in ab]
    [g[b-1].append(a-1) for a, b in ab]
    mod = 10**9+7
    fact = [1, 1]
    for i in range(2, 200001):
        fact.append(fact[-1]*i % mod)

    def nCr(n, r, mod=10**9+7):
        return pow(fact[n-r]*fact[r], mod-2, mod)*fact[n] % mod

    # 頂点iについて、jが根のときのDPの値を求める（アクセス時間を考慮してここで定義）
    def calc(i, j):
        root = tree_d[i][j]+1
        try:
            return tc_l[i][root-1]+tc_r[i][root]
        except:
            return tc_l[i][root-1]

    def calc2(i, j):
        root = tree_d[i][j]+1
        try:
            return tc_l2[i][root-1]*tc_r2[i][root] *\
                nCr(tc_l[i][root-1]+tc_r[i]
                    [root], tc_l[i][root-1]) % mod
        except:
            return tc_l2[i][root-1]

    tree = g
    size = len(tree)
    dp, dp2, order, q, anc = [0]*size, [1]*size, [], [0], [-1]*n
    oa, qa, qp = order.append, q.append, q.pop
    tree_d = [{k: j for j, k in enumerate(i)} for i in g]
    g_size = [len(i) for i in g]
    tc_l = [[0]*(i+1) for i in g_size]
    tc_r = [[0]*i for i in g_size]
    tc_l2 = [[1]*(i+1) for i in g_size]
    tc_r2 = [[1]*i for i in g_size]

    # トポロジカル順序をorderに記録、0を根とする根付き木上のiの祖先をanc[i]とする
    while q:
        i = qp()
        a = anc[i]
        oa(i)
        for j in g[i]:
            if j != a:
                qa(j)
                anc[j] = i

    # dpおよびtree_preに記録
    for i in order[:0:-1]:
        a = anc[i]
        t = tree_d[a][i]
        d = dp2[i]
        tc_l2[a][t+1], tc_r2[a][t] = d, d
        d = dp[i]+1
        tc_l[a][t+1], tc_r[a][t], dp[a] = d, d, dp[a]+d
        dp2[a] = dp2[a]*dp2[i]*nCr(dp[a], dp[i]+1) % mod

    # 頂点0のみ先に処理
    ans = 0
    for j in range(1, g_size[0]+1):
        tc_l[0][j] = tc_l[0][j]+tc_l[0][j-1]
        tc_l2[0][j] = tc_l2[0][j]*tc_l2[0][j-1] * \
            nCr(tc_l[0][j], tc_l[0][j-1]) % mod
    for j in range(g_size[0]-2, 0, -1):
        tc_r[0][j] = tc_r[0][j]+tc_r[0][j+1]
        tc_r2[0][j] = tc_r2[0][j]*tc_r2[0][j+1] * \
            nCr(tc_r[0][j], tc_r[0][j+1]) % mod

    # 行きがけ順に処理
    for i in order[1:]:
        a = anc[i]
        d, c, c2, length = tree_d[i][a], calc(
            a, i)+1, calc2(a, i), g_size[i]

        tc_l[i][d+1], tc_r[i][d] = c, c
        tc_l2[i][d+1], tc_r2[i][d] = c2, c2

        for j in range(1, length+1):
            tc_l[i][j] = tc_l[i][j]+tc_l[i][j-1]
            tc_l2[i][j] = tc_l2[i][j]*tc_l2[i][j-1] * \
                nCr(tc_l[i][j], tc_l[i][j-1]) % mod
        for j in range(length-2, 0, -1):
            tc_r[i][j] = tc_r[i][j+1]+tc_r[i][j]
            tc_r2[i][j] = tc_r2[i][j]*tc_r2[i][j+1] * \
                nCr(tc_r[i][j], tc_r[i][j+1]) % mod
        dp[i] = tc_l[i][-1]
        dp2[i] = tc_l2[i][-1]
    for i in dp2:
        print(i)


main()


### FIXED CODE ###

def main():
    mod = 10**9+7
    fact = [1, 1]
    for i in range(2, 200000):
        fact.append(fact[-1]*i % mod)
    n = int(input())
    ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
    g = [[] for _ in [0]*n]
    [g[a-1].append(b-1) for a, b in ab]
    [g[b-1].append(a-1) for a, b in ab]
    g2 = [set(i) for i in g]
    child = [1]*n  # 子の数
    q = [-1, 0]
    while len(q) > 1:  # DFS
        i = q[-1]
        if g2[i]:
            j = g2[i].pop()
            g2[j].remove(i)
            q.append(j)
        else:
            q.pop()
            if len(q) > 1:
                child[q[-1]] += child[i]
    rank = [(j, i) for i, j in enumerate(child)]
    rank = [j for i, j in sorted(rank)]
    dp = [1]*n
    for i in rank:
        c = child[i]
        ans = fact[c-1]
        temp = 1
        for j in g[i]:
            if child[j] < c:
                ans = ans*dp[j] % mod
                temp = temp*fact[child[j]] % mod
        dp[i] = ans*pow(temp, mod-2, mod) % mod
    dp2 = [0]*n
    dp2[0] = dp[0]
    g2 = [set(i) for i in g]
    q = [-1, 0]
    while len(q) > 1:  # DFS
        i = q[-1]
        if g2[i]:
            j = g2[i].pop()
            c = child[j]
            temp = fact[n-c]*fact[c-1]
            dp2[j] = dp2[i]*(fact[c]*fact[n-c-1])*pow(temp, mod-2, mod) % mod
            g2[j].remove(i)
            q.append(j)
        else:
            q.pop()
            if len(q) > 1:
                child[q[-1]] += child[i]

    for i in dp2:
        print(i)


main()