import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.IntStream;

public class SolutionIvan {
    public static void main(String[] args) throws IOException {
        new SolutionIvan().run();
    }

    BufferedReader input;
    StringTokenizer tokenizer;
    String next() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(input.readLine());
        }
        return tokenizer.nextToken();
    }
    int nextInt() {
        try {
            return Integer.parseInt(next());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static final int MOD = 1000000007;
    int n;
    List<List<Integer>> g;
    int p[];
    int pi[];
    int count[];

    int z[][];

    static int mul(int lhs, int rhs) {
        return (int)(((long)lhs * (long)rhs) % MOD);
    }

    public void run() throws IOException {
        input = new BufferedReader(new InputStreamReader(System.in));
        n = nextInt();
        g = new ArrayList<>(n);
        for (int i = 0; i < n; ++i) {
            g.add(new ArrayList<>(n));
        }

        p = new int[n];
        pi = new int[n];
        count = new int[n];
        Arrays.fill(count, 0);

        p[0] = -1;
        pi[0] = 0;
        count[0] = 1;

        for (int v = 1; v < n; ++v) {
            p[v] = nextInt();
            pi[v] = g.get(p[v]).size();
            g.get(p[v]).add(v);

            int u = v;
            while (u != -1) {
                ++count[u];
                u = p[u];
            }
        }

        z = new int[n][n + 1];
        for (int i = 0; i < n; ++i) {
            Arrays.fill(z[i], 0);
        }

        for (int v = n - 1; v >= 1; --v) {
            z[v][0] = 1;
            for (int c = 1; c <= count[p[v]]; ++c) {
                int u = p[v];
                if (pi[v] + 1 == g.get(u).size()) {
                    if (g.get(v).isEmpty()) {
                        z[v][c] = (c == 1) ? 1 : 0;
                    } else {
                        z[v][c] = z[g.get(v).get(0)][c - 1];
                    }
                } else {
                    int s = g.get(u).get(pi[v] + 1);
                    int total = z[s][c];
                    for (int left = 1; left <= Math.min(c, count[v]); ++left) {
                        int cur = z[s][c - left];
                        if (g.get(v).isEmpty()) {
                            if (left != 1) {
                                cur = 0;
                            }
                        } else {
                            cur = mul(cur, z[g.get(v).get(0)][left - 1]);
                        }
                        total = (total + cur) % MOD;
                    }
                    z[v][c] = total;
                }
            }
        }

        for (int c = 1; c <= n; ++c) {
            int total = 0;
            for (int v = 0; v < n; ++v) {
                int cur;
                if (g.get(v).isEmpty()) {
                    cur = (c == 1) ? 1 : 0;
                } else {
                    cur = z[g.get(v).get(0)][c - 1];
                }
                total = (total + cur) % MOD;
            }
            System.out.println(total);
        }
    }
}