#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define SZ(a) ((int)a.size())
#define pb push_back
#define ALL(v) v.begin(), v.end()

const int N = 200005;

template<class T>
struct BIT {
    int n;
    T bit[N], org[N];
    void init(int _n) {
        n = _n;
        fill_n(bit + 1, n, 0);
        fill_n(org + 1, n, 0);
    }
    void modify(int x, T v) {
        for (org[x] += v; x <= n; x += x & -x)
            bit[x] += v;
    }
    T query(int x) {
        T res = 0;
        for (; x; x -= x & -x)
            res += bit[x];
        return res;
    }
};

BIT<int> counts;
BIT<ll> weighted;

struct Heavy_light_Decomposition {
    int n, ulink[N], deep[N], mxson[N], w[N], pa[N];
    int t, pl[N], data[N], mx[N];
    vector<int> G[N];
    void init(int _n) {
        n = _n, t = 0;
        for (int i = 1; i <= n; ++i)
            G[i].clear(), mxson[i] = 0, mx[i] = 0;
    }
    void add_edge(int a, int b) {
        G[a].pb(b);
        G[b].pb(a);
    }
    void dfs(int u, int f, int d) {
        w[u] = 1, pa[u] = f, deep[u] = d++;
        for (auto &i : G[u])
            if (i != f) {
                dfs(i, u, d), w[u] += w[i];
                if (w[mxson[u]] < w[i]) mxson[u] = i;
            }
    }
    void cut(int u, int link) {
        pl[u] = ++t, ulink[u] = link;
        mx[link] = max(mx[link], pl[u]);
        if (!mxson[u]) return;
        cut(mxson[u], link);
        for (auto i : G[u])
            if (i != pa[u] && i != mxson[u])
                cut(i, i);
    }
    void build() {
        dfs(1, 0, 1);
        cut(1, 1);
        counts.init(n); 
        weighted.init(n);
    }
    void modify(int u) {
        while (u) {
            counts.modify(pl[u], 1);
            weighted.modify(pl[u], data[u]);
            u = pa[ulink[u]]; 
        }
    }
    ll query(int u) {
        ll res = 0, prv = 0;
        while (u) {
            int boss = ulink[u];
            ll below = counts.query(mx[boss]) - counts.query(pl[u]) + counts.org[pl[u]];
            res += (below - prv) * data[u];
            res += weighted.query(pl[u] - 1) - weighted.query(pl[boss] - 1);
            prv = counts.query(mx[boss]) - counts.query(pl[boss] - 1);
            u = pa[boss];
        }
        return res;
    }
} hld;

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int n;
    while (cin >> n) {
        hld.init(n);
        for (int i = 1; i <= n; ++i)
            cin >> hld.data[i];
        for (int i = 2; i <= n; ++i) {
            int p;
            cin >> p;
            hld.add_edge(p, i);
        }
        hld.build();
        for (int i = 2; i <= n; ++i) {
            hld.modify(i - 1);
            cout << hld.query(i) << "\n";
        }
    }
}