The country has *n* cities and *n* - 1 bidirectional roads, it is possible to get from every city to any other one if you move only along the roads. The cities are numbered with integers from 1 to *n* inclusive.

All the roads are initially bad, but the government wants to improve the state of some roads. We will assume that the citizens are happy about road improvement if the path from the capital located in city *x* to any other city contains at most one bad road.

Your task is — for every possible *x* determine the number of ways of improving the quality of some roads in order to meet the citizens' condition. As those values can be rather large, you need to print each value modulo 1 000 000 007 (10<sup class="upper-index">9</sup> + 7).
The first line of the input contains a single integer *n* (2 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>) — the number of cities in the country. Next line contains *n* - 1 positive integers *p*<sub class="lower-index">2</sub>, *p*<sub class="lower-index">3</sub>, *p*<sub class="lower-index">4</sub>, ..., *p*<sub class="lower-index">*n*</sub> (1 ≤ *p*<sub class="lower-index">*i*</sub> ≤ *i* - 1) — the description of the roads in the country. Number *p*<sub class="lower-index">*i*</sub> means that the country has a road connecting city *p*<sub class="lower-index">*i*</sub> and city *i*.
# Day1
# C. Basketball Exercise
# https://codeforces.com/problemset/problem/1195/C
"""
输入 n(1≤n≤1e5) 和一个 2 行 n 列的矩阵 a(1≤a[i][j]≤1e9)。
你需要从矩阵中选择一些数，要求任意两数不能左右相邻，也不能上下相邻。
输出所选数字之和的最大值。

思考：如果改成 m 列要怎么做？ https://ac.nowcoder.com/acm/contest/59157/O
输入
5
9 3 5 7 3
5 8 1 4 5
输出 29

输入
3
1 2 9
10 1 1
输出 19

输入
1
7
4
输出 7
"""
# 经典打家劫舍dp，m列建议网络流算法！
# n = int(input())
# a = list(map(int, input().split()))
# b = list(map(int, input().split()))
#
# x,y = 0,0
# for i in range(n):
#     x,y = max(x, y + a[i]), max(y, x + b[i])
# print(max(x,y))

# Day2
# A. Dynasty Puzzles
# https://codeforces.com/problemset/problem/191/A
"""
输入 n(1≤n≤5e5) 和长为 n 的字符串数组 a，只包含小写字母，每个 a[i] 的长度至多为 10。

你需要选择 a 的一个子序列 b，满足 b[i] 的最后一个字母等于 b[i+1] 的第一个字母，且 b[0] 的第一个字母等于 b[-1] 的最后一个字母。这里 b[-1] 表示最后一项。
输出 b 中字符串长度之和的最大值。

注：子序列不要求连续。
输入
3
abc
ca
cba
输出 6

输入
4
vvp
vvp
dam
vvp
输出 0

输入
3
ab
c
def
输出 1
"""
# import sys
# input = sys.stdin.readline
# n = int(input())
# li = [input().strip() for _ in range(n)]
#
# dp = [[0] * 26 for _ in range(26)]
#
# for s in li:
#     head = ord(s[0]) - ord('a')
#     tail = ord(s[-1]) - ord('a')
#
#     for x in range(26):
#         if not dp[head][x]:
#             continue
#         dp[tail][x] = max(dp[tail][x], dp[head][x] + len(s))
#     # 晚加排除自交情况
#     dp[tail][head] = max(dp[tail][head], len(s))
# print(max(dp[i][i] for i in range(26)))

# Day3
# D. Watch the Videos
# https://codeforces.com/problemset/problem/1765/D
"""
输入 n(1≤n≤2e5) m(1≤m≤1e9) 和长为 n 的数组 a(1≤a[i]≤m)。
硬盘可用空间为 m。
有 n 个视频，下载第 i 个需要 a[i] 分钟，占用 a[i] 的硬盘空间。
同一时间只能下载一个视频，一旦视频开始下载，就会立刻占用 a[i] 的硬盘空间。
视频下完才能看。每个视频都恰好花 1 分钟看完，看完后可以立刻删除视频，释放空间。
你可以在看视频的同时下载另一个视频（如果硬盘空间足够的话）。
你需要下载并看完这 n 个视频。
问：到看完最后一个视频，最少要用多少分钟？
输入
5 6
1 2 3 4 5
输出 16

输入
5 5
1 2 3 4 5
输出 17

输入
4 3
1 3 2 3
输出 12
"""
# 同一时间只能下载一个视频
# 为主只需要看看的时间能不能多与下载时间叠起来
# 同一时间有两部视频
# n,m = map(int, input().split())
# a = list(map(int, input().split()))
# a.sort()
#
# ans = sum(a)
# i = 0
# j = n - 1
# while i < j:
#     if a[i] + a[j] <= m:
#         j -= 1
#         i += 1
#     else:
#         ans += 1
#         j -= 1
# print(ans + 1)

# Day4
# D. MEX Sequences
# https://codeforces.com/problemset/problem/1613/D
"""
输入 T(≤1e5) 表示 T 组数据。所有数据的 n 之和 ≤5e5。
每组数据输入 n(1≤n≤5e5) 和长为 n 的数组 a(0≤a[i]≤n)。

称序列 b 为 MEX 序列，如果对所有 i 都有 abs(b[i] - mex(b[0],...,b[i])) ≤ 1 成立，其中 mex(S) 表示不在 S 中的最小非负整数。
输出 a 的非空 MEX 子序列的个数，模 998244353。
两个子序列只要有元素下标不同，就算不同的子序列。例如 a=[0,0,0] 有 7 个不同的非空子序列。
注：子序列不要求连续。
输入
4
3
0 2 1
2
1 0
5
0 0 0 0 0
4
0 1 2 3
输出
4
2
31
7
"""
# 这dp也太复杂了，情况太多了，不好想。
# 答案只有000111222类似这种情况的子序列个数，或者111、000222000终止。
# import sys
# input = sys.stdin.readline
# t = int(input())
# mod = 998244353
# for _ in range(t):
#     n = int(input())
#     a = list(map(int, input().split()))
#     dp = [[0]*3 for _ in range(n + 10)]
#
#     ans = pow(2,a.count(1),mod) - 1
#     for i in range(n):
#         x = a[i]
#         if x == 0:
#             dp[x][0] = (dp[x][0] * 2 + 1) % mod
#         else:
#             dp[x][0] = (dp[x - 1][0] + 2*dp[x][0])%mod
#         # 进入+2-2循环再也不可以+1-1了
#         dp[x][1] = (2 * dp[x][1] + dp[x - 2][0] + dp[x - 2][2])%mod
#         dp[x][2] = (2 * dp[x][2] + dp[x + 2][1])%mod
#     # print(dp)
#     print((ans + sum(sum(x) for x in dp))%mod)

# Day5
# D. Road Improvement
# https://codeforces.com/problemset/problem/543/D
"""
输入 n(2≤n≤2e5) 和 n-1 个数 p2,p3,...,pn，表示一棵 n 个节点的无根树，节点编号从 1 开始，i 与 pi(1≤pi≤i-1) 相连。
定义 a(x) 表示以 x 为根时的合法标记方案数，模 1e9+7。其中【合法标记】定义为：对树的某些边做标记，使得 x 到任意点的简单路径上，至多有一条边是被标记的。
输出 a(1),a(2),...,a(n)。
输入
3
1 1
输出
4 3 3

输入
5
1 2 3 4
输出
5 8 9 8 5
"""
n = int(input())
p = list(map(int, input().split()))
mod = 10 ** 9 + 7
g = [[] for _ in range(n)]
for i in range(n - 1):
    g[p[i] - 1].append(i + 1)
    g[i + 1].append(p[i] - 1)

count = [[0, 1] for _ in range(n)]
from types import GeneratorType
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc

def mul(x, y):
    e1, x1 = x
    e2, x2 = y
    if x2 + 1 == mod:
        e1 = e1 + e2 + 1
    else:
        e1 = e1 + e2
        x1 = x1 * (x2 + 1) % mod
    return [e1, x1]


def div(x, y):
    e1, x1 = x
    e2, x2 = y
    if x2 + 1 == mod:
        e1 = e1 - e2 - 1
    else:
        e1 = e1 - e2
        x1 = x1 * pow(x2 + 1, mod - 2, mod) % mod
    return [e1, x1]

@bootstrap
def dfs1(son, fa):
    for x in g[son]:
        if x != fa:
            yield dfs1(x, son)
            count[son] = mul(count[son], count[x])
    yield

dfs1(0, -1)

ans = [[0, 1] for _ in range(n)]

@bootstrap
def dfs2(son, fa, from_fa):
    ans[son] = mul(count[son], from_fa)
    for x in g[son]:
        if x != fa:
            yield dfs2(x, son, div(ans[son], count[x]))
    yield

dfs2(0, -1, [0, 0])
print(*[x[1] if x[0] == 0 else 0 for x in ans])