#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
//	mt19937 engine((unsigned ll)time(NULL));
//	uniform_int_distribution<ll> distribution(0, (ll)1e18);
//	auto generator = bind(distribution, engine);
//	ll x = generator();
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
// #define ordered_multiset tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vl = std::vector<ll>;
using vii = std::vector<pair<int, int> >;
using vvl = std::vector<vl>;
using vll = std::vector<pair<ll , ll> >;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using vs = std::vector<std::string>;
using vvs = std::vector<vs>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vc = std::vector<char>;
using vvc = std::vector<vc>;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using piil = std::pair<pair<int, int>, ll>;
using mii = std::map<int, int>;
using mll = std::map<ll, ll>;
using pql = std::priority_queue<ll>;
using pqi = std::priority_queue<int>;
using pqiil = std::priority_queue<pair<pair<int, int>, ll> >;
using pqii = std::priority_queue<pair<int, int> >;

#define pb push_back
#define ps push
#define eb emplace_back
#define is insert
#define er erase
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sf(i) sizeof(i)
#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define rep(i, L, R) for(ll i = L;i<=R;i++)
#define pcis precision
#define sz(a) ((ll) a.size())

template<typename T>
struct infinity {
	static constexpr T max=std::numeric_limits<T>::max();
	static constexpr T min=std::numeric_limits<T>::min();
	static constexpr T value=std::numeric_limits<T>::max()/2;
	static constexpr T mvalue=std::numeric_limits<T>::min()/2;
};
template<typename T>constexpr T INF=infinity<T>::value;
constexpr ll lINF=INF<ll>;
constexpr int iINF = INF<int>;
constexpr ld PI = 3.1415926535897932384626;

#include "tree.h"
ll N;
vl adj[420001];
ll W[420001];

pll ruseki[420001];// L : R 있는거임
// R/L = i일 때 식

// 값 : 용량  (값은 작을수록 터질 확률이 높음)
void zensyori(ll node) {
	if (adj[node].size() == 0) {
		ruseki[0].f += W[node];// 이만큼 빡 힘을 줘야함
		return;
	}
	for (auto i : adj[node]) zensyori(i);
	ruseki[0].f += (((ll) adj[node].size())-1)*W[node];// 걍 싹다 받아서, L 하나만 내놓자.
	return;
}


// 값 : 용량  (값은 작을수록 터질 확률이 높음)
priority_queue<pll> DFS(ll node) {
	priority_queue<pll> pq;
	ll my_ryu = (((ll) adj[node].size())-1);
	for (auto i : adj[node]) {
		if (adj[i].size() == 0) continue;
		auto pq2 = DFS(i);

		ll sakki_ryu = 0;

		while (!pq2.empty() && W[node] <= pq2.top().f) {
			// 저새끼는 빼는게? 이득 아닌가
			auto [W2, ryu] = pq2.top();
			pq2.pop();
			ll w = W[node] - W2;// (w*흐르는 양)만큼 이득임
			// 여기다가 바로 안 흘리고
			// 위로 올릴수도 있나? 오 씨발 존나 그럴싸한데?
			// 아 잠만 이제 바뀌었다. 그냥 그걸 그대로 올리는 것이다 

			// min((R - (1 + sakki_ryu)*L), ryu*L) 만큼 흘릴 수 있다

			// R >= (1 + sakki_ryu + ryu)*L  -> R-(1+sakki_ryu)*L
			//  < 이면 -> ryu*L 임
			// 아니 반대임

			ruseki[0].f += -(1+sakki_ryu)*w;
			ruseki[0].s += w;
			
			assert(1 + sakki_ryu + ryu <= N);
			ruseki[1 + sakki_ryu + ryu].f -= -(1+sakki_ryu)*w;
			ruseki[1 + sakki_ryu + ryu].s -= w;

			ruseki[1 + sakki_ryu + ryu].f += ryu*w;

			my_ryu += ryu;// 저만큼 유량을 흘려줄 수 있음
			sakki_ryu += ryu;
		}

		if (pq.size() < pq2.size()) swap(pq, pq2);
		while (!pq2.empty()) pq.ps(pq2.top()), pq2.pop();
	}
	pq.ps({W[node], my_ryu});
	return pq;
}


void init(std::vector<int> P, std::vector<int> W) {
	::N = P.size();
	rep(i,0,N-1) adj[P[i]+1].pb(i+1);
	rep(i, 1, N) ::W[i] = W[i-1];
	::W[0] = 0;

	zensyori(0);
	DFS(0);

	rep(i, 1, N*2) ruseki[i].f += ruseki[i-1].f;
	rep(i, 1, N*2) ruseki[i].s += ruseki[i-1].s;

	return;
}

long long query(int _L, int _R) {
	ll L = _L;
	ll R = _R;
	ll cc = R/L;// R/L값에 따라 달라지는게 맞나?
	cc = min(cc, N*2);
	return L*ruseki[cc].f + R*ruseki[cc].s;
}

//
//void _main();
//int main() {
//	cin.tie(0);
//	ios::sync_with_stdio(false);
//	_main();
//	return 0;
//}
//void _main() {
//
//	ll N;
//	cin >> N;
//	vi P(N);
//	P[0] = -1;
//	rep(i, 1, N-1) cin >> P[i];
//	vi W(N);
//	rep(i, 0, N-1) cin >> W[i];
//
//	init(P, W);
//
//	ll Q;
//	cin >> Q;
//	while (Q--) {
//		ll l, r;
//		cin >> l >> r;
//		cout << query(l, r) << endl;
//	}
//
//
//}