#include <bits/stdc++.h>

using namespace std;

const int MAX = 5e3 + 5;
const int mod = 1e9 + 7;

struct mint{
    int v;
    mint() : v(0) {}
    mint(int v) : v(v) {}

    mint& operator += (const mint& o){
        v += o.v;
        if(v >= mod) v -= mod;
        return *this;
    }

    mint& operator -= (const mint& o){
        v -= o.v;
        if(v < 0) v += mod;
        return *this;
    }

    mint& operator *= (const mint& o){
        v = 1LL * v * o.v % mod;
        return *this;
    }

    mint power(long long n) const{
        mint res(1);
        mint base = *this;
        for(; n > 0; n >>= 1, base *= base){
            if(n & 1) res *= base;
        }
        return res;
    }

    mint inv() const {
        return power(mod - 2);
    }

    mint& operator /= (const mint& o){
        return *this *= o.inv();
    }

    friend mint operator + (mint a, const mint& b){ return a += b; }
    friend mint operator - (mint a, const mint& b){ return a -= b; }
    friend mint operator * (mint a, const mint& b){ return a *= b; }
    friend mint operator / (mint a, const mint& b){ return a /= b; }

    friend ostream& operator << (ostream& out, const mint& v){
        return out << v.v;
    }
};

int N, p[MAX], sz[MAX], depth[MAX];
mint A[MAX], fact[MAX], ifact[MAX], dp[MAX], f[MAX][MAX];
vector<int> adj[MAX];
mint ans[MAX];

void prepare(int N){
    fact[0] = ifact[0] = 1;
    for(int i = 1; i <= N; ++i){
        fact[i] = fact[i - 1] * mint(i);
    }

    ifact[N] = fact[N].inv();
    for(int i = N - 1; i >= 1; --i){
        ifact[i] = ifact[i + 1] * mint(i + 1);
    }
}

mint C(int n, int k){
    if(n < k || k < 0) return mint(0);
    return fact[n] * ifact[n - k] * ifact[k];
}

mint iC(int n, int k){
    if(n < k || k < 0) return mint(0);
    return ifact[n] * fact[n - k] * fact[k];
}

void dfs(int u){
    dp[u] = 1;
    for(int v : adj[u]){
        depth[v] = depth[u] + 1;
        dfs(v);
        sz[u] += sz[v];
        dp[u] *= dp[v] * C(sz[u], sz[v]);
    }

    sz[u] += 1;
}

mint pref[MAX];

void dfs_dp(int u){
    for(int v : adj[u]){
        for(int i = 0; i < N; ++i){
            pref[i] = (i == 0 ? 0 : pref[i - 1]) + f[u][i] * iC(N - i - 1, sz[v]);
        }

        for(int i = 1; i < N; ++i){
            f[v][i] = pref[i - 1] * C(N - i - 1, sz[v] - 1);
        }

        dfs_dp(v);
    }
}

int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);

#ifdef LOCAL
    freopen("task.inp", "r", stdin);
    freopen("task.out", "w", stdout);
#endif // LOCAL

    cin >> N;
    for(int i = 1; i < N; ++i){
        cin >> p[i]; --p[i];
        adj[p[i]].emplace_back(i);
    }

    for(int i = 0; i < N; ++i){
        int x; cin >> x;
        A[i] = mint(x);
    }

    prepare(2 * N);
    dfs(0);

    f[0][0] = dp[0];
    dfs_dp(0);

    for(int i = 0; i < N; ++i){
        for(int j = 0; j < N; ++j){
            ans[i] += A[j] * f[i][j];
//            cout << f[i][j] << ' ';
        }
//        cout << '\n';
    }

    for(int i = 0; i < N; ++i) cout << ans[i] << ' ';

    return 0;
}