#include "tree.h"
#include <bits/stdc++.h>
using namespace std;

using ll = long long;

namespace Solve {

const int maxN  = 200'023;

int N;
vector<int> child[maxN];
ll W[maxN];
ll val[maxN];

ll dfs(int cur, ll L, ll R) {
    val[cur] = 0;
    ll ret = 0;
    for (auto nxt : child[cur]) {
        ret += dfs(nxt, L, R);
        val[cur] += val[nxt];
    }

    if (val[cur] < L) {
        ret += (L - val[cur]) * W[cur];
        val[cur] = L;
    } else if (val[cur] > R) {
        ret += (val[cur] - R) * W[cur];
        val[cur] = R;
    }
    return ret;
}

} // namespace Solve

void init(vector<int> P, vector<int> W) {
    Solve::N = P.size();
    for (int i = 1; i < Solve::N; i++) Solve::child[P[i]].push_back(i);
    for (int i = 0; i < Solve::N; i++) Solve::W[i] = W[i];
}

ll query(int L, int R) {
    return Solve::dfs(0, L, R);
}

#ifdef Zanite

#include "tree.h"
#include <cassert>
#include <cstdio>

int main() {
    int N;
    assert(1 == scanf("%d", &N));
    vector<int> P(N);
    P[0] = -1;
    for (int i = 1; i < N; i++)
        assert(1 == scanf("%d", &P[i]));
    vector<int> W(N);
    for (int i = 0; i < N; i++)
        assert(1 == scanf("%d", &W[i]));
    int Q;
    assert(1 == scanf("%d", &Q));
    vector<int> L(Q), R(Q);
    for (int j = 0; j < Q; j++)
        assert(2 == scanf("%d%d", &L[j], &R[j]));
    fclose(stdin);

    init(P, W);
    vector<long long> A(Q);
    for (int j = 0; j < Q; j++)
        A[j] = query(L[j], R[j]);

    for (int j = 0; j < Q; j++)
        printf("%lld\n", A[j]);
    fclose(stdout);

    return 0;
}

#endif