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

using ll  = long long;
using pll = pair<ll, ll>;

#define fi first
#define se second

#define All(x)   x.begin(), x.end()
#define debug(x) cout << #x << " = " << x << "\n"

template<typename T> bool chmax(T &u, T v) { if (u < v) { u = v; return true; } return false; }

template<typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U> &v) {
    return os << "(" << v.fi << ", " << v.se << ")";
}
template<typename T>
ostream& operator<<(ostream& os, const vector<T> &v) {
    os << "["; bool _first = true;
    for (auto i : v) { if (!_first) { os << ", "; } os << i; _first = false; }
    return os << "]";
}
template<typename T>
ostream& operator<<(ostream& os, const deque<T> &v) {
    os << "["; bool _first = true;
    for (auto i : v) { if (!_first) { os << ", "; } os << i; _first = false; }
    return os << "]";
}

namespace Solve {

struct Func {
    ll start;
    deque<pll> slopes;

    Func() : start(0), slopes(0) {}
    Func(ll L, ll R, ll W) {
        start = L*W;
        slopes = {{R - L, W}};
    }

    ll getMinimum() {
        ll ret = start, run = start;
        for (int i = 0; i < (int)slopes.size(); i++) {
            run += slopes[i].fi * slopes[i].se;
            ret = min(ret, run);
        }
        return ret;
    }

    static Func merge(Func a, Func b, ll L, ll R, ll W) {
        Func ret;
        ret.start = a.start + b.start;
        ret.slopes = {};
        ll cx = 2ll * L;

        while (!a.slopes.empty() || !b.slopes.empty()) {
            // cerr << a.slopes.size() << " " << b.slopes.size() << "\n";

            if (!a.slopes.empty() && !b.slopes.empty()) {
                if (a.slopes.front().se < b.slopes.front().se) {
                    ret.slopes.push_back(a.slopes.front());
                    a.slopes.pop_front();
                } else {
                    ret.slopes.push_back(b.slopes.front());
                    b.slopes.pop_front();
                }
            } else if (!a.slopes.empty()) {
                ret.slopes.push_back(a.slopes.front());
                a.slopes.pop_front();
            } else {
                ret.slopes.push_back(b.slopes.front());
                b.slopes.pop_front();
            }
        }

        // pad front
        while (!ret.slopes.empty() && ret.slopes.front().se < -W) {
            ret.start += ret.slopes.front().fi * ret.slopes.front().se;
            cx += ret.slopes.front().fi;
            ret.slopes.pop_front();
        }
        ret.slopes.push_front({cx - L, -W});
        ret.start -= ret.slopes.front().fi * ret.slopes.front().se;

        // pop back
        ll sum = 0;
        for (auto [len, slope] : ret.slopes) sum += len;
        while (sum > R-L) {
            ll tk = sum - (R-L);
            // cerr << "tk " << tk << "\n";
            if (ret.slopes.back().fi <= tk) {
                sum -= ret.slopes.back().fi;
                if (ret.slopes.size() > 1) {
                    ret.slopes.pop_back();
                } else {
                    ret.slopes.back().fi = 0;
                }
            } else {
                ret.slopes.back().fi -= tk;
                break;
            }
        }
        // cerr << ret.slopes << "\n";

        return ret;
    }

    static Func clip(Func a, ll L, ll R, ll W) {
        // pad front
        ll cx = L;
        while (a.slopes.front().se < -W) {
            a.start += a.slopes.front().fi * a.slopes.front().se;
            cx += a.slopes.front().fi;
            a.slopes.pop_front();
        }
        a.slopes.push_front({cx - L, -W});
        a.start -= a.slopes.front().fi * a.slopes.front().se;

        // pad back
        ll rem = 0;
        while (a.slopes.back().se > W) {
            rem += a.slopes.back().fi;
            a.slopes.pop_back();
        }
        a.slopes.push_back({R - L - rem, W});

        return a;
    }
};

const int maxN  = 200'023;

int N;
vector<int> child[maxN];
ll W[maxN];
Func F[maxN];
ll L, R;

void dfs(int cur) {
    if (child[cur].empty()) {
        F[cur] = Func(L, R, W[cur]);
        return;
    }

    for (auto nxt : child[cur]) dfs(nxt);

    if (child[cur].size() == 1) {
        F[cur] = Func::clip(F[child[cur][0]], L, R, W[cur]);
    } else {
        F[cur] = Func::merge(F[child[cur][0]], F[child[cur][1]], L, R, W[cur]);
        for (int i = 2; i < (int)child[cur].size(); i++) {
            F[cur] = Func::merge(F[cur], F[child[cur][1]], L, R, W[cur]);
        }
    }
}

} // 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) {
    Solve::L = L, Solve::R = R;
    Solve::dfs(0);
    return Solve::F[0].getMinimum();
}

#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