#include <bits/stdc++.h>
// #pragma GCC optimize(2)
#define int long long
#define pii pair<int, int>
#define tpi tuple<int, int, int, int>
#define il inline
#define p_q priority_queue
#define u_m unordered_map
#define bt bitset
#define rg register
#define rep(i, x, y) for (int i = (x); i <= (y); i++)
#define per(i, x, y) for (int i = (x); i >= (y); i--)
using namespace std;
const int N1 = 300005;
const int N2 = 1000006;
const int mod = 998244353;
using i64 = long long;
void chmin(int& x, int c) {
x = min(x, c);
}
void chmax(int& x, int c) {
x = max(x, c);
}
namespace fast_IO {
#define IOSIZE 100000
int precision = 3, POW[10] = {1, 10, 100, 1000, 10000,
100000, 1000000, 10000000, 100000000, 1000000000
};
char ibuf[IOSIZE], obuf[IOSIZE], *p1 = ibuf, *p2 = ibuf, *p3 = obuf;
// #ifdef ONLINE_JUDGE
// #define getchar() \
// ((p1 == p2) and \
// (p2 = (p1 = ibuf) + fread(ibuf, 1, IOSIZE, stdin), p1 == p2) \
// ? (EOF) \
// : (*p1++))
// #define putchar(x)
// ((p3 == obuf + IOSIZE) && (fwrite(obuf, p3 - obuf, 1, stdout), p3 = obuf),
// *p3++ = x)
// #define isdigit(ch) (ch > 47 && ch < 58)
// #define isspace(ch) (ch < 33)
// #endif
template <typename T>
inline T read() {
T s = 0;
int w = 1;
char ch;
while (ch = getchar(), !isdigit(ch) && (ch != EOF))
if (ch == 45)
w = -1;
if (ch == EOF)
return 0;
while (isdigit(ch))
s = s * 10 + ch - 48, ch = getchar();
return s * w;
}
template <typename T>
inline bool read(T& s) {
s = 0;
int w = 1;
char ch;
while (ch = getchar(), !isdigit(ch) && (ch != EOF))
if (ch == 45)
w = -1;
if (ch == EOF)
return 0;
while (isdigit(ch))
s = s * 10 + ch - 48, ch = getchar();
return s *= w, 1;
}
inline bool read(char& s) {
while (s = getchar(), isspace(s))
;
return 1;
}
inline bool read(char* s) {
char ch;
while (ch = getchar(), isspace(ch))
;
if (ch == EOF)
return 0;
while (!isspace(ch))
*s++ = ch, ch = getchar();
*s = '\000';
return 1;
}
template <typename T>
inline void print(T x) {
if (x < 0)
putchar(45), x = -x;
if (x > 9)
print(x / 10);
putchar(x % 10 + 48);
}
inline void print(char x) {
putchar(x);
}
inline void print(char* x) {
while (*x)
putchar(*x++);
}
inline void print(const char* x) {
for (int i = 0; x[i]; i++)
putchar(x[i]);
}
inline bool read(std::string& s) {
s = "";
char ch;
while (ch = getchar(), isspace(ch))
;
if (ch == EOF)
return 0;
while (!isspace(ch))
s += ch, ch = getchar();
return 1;
}
inline void print(std::string x) {
for (int i = 0, n = x.size(); i < n; i++)
putchar(x[i]);
}
inline bool read(bool& b) {
char ch;
while (ch = getchar(), isspace(ch))
;
b = ch ^ 48;
return 1;
}
inline void print(bool b) {
putchar(b + 48);
}
inline bool read(double& x) {
int a = 0, b = 0;
char ch = getchar();
bool f = 0;
while (ch < 48 || ch > 57) {
if (ch == 45)
f = 1;
ch = getchar();
}
while (47 < ch && ch < 58) {
a = (a << 1) + (a << 3) + (ch ^ 48);
ch = getchar();
}
if (ch != 46) {
x = f ? -a : a;
return 1;
}
ch = getchar();
while (47 < ch && ch < 58) {
b = (b << 1) + (b << 3) + (ch ^ 48), ch = getchar();
}
x = b;
while (x > 1) x /= 10;
x /= 10;
x = f ? -a - x : a + x;
return 1;
}
inline void print(double x) {
if (x < 0) {
putchar(45), x = -x;
}
x = round((long double)x * POW[precision]) / POW[precision],
print((long long)x), putchar(46), x -= (long long)(x);
for (int i = 1; i <= precision; i++)
x *= 10, putchar(x + 48), x -= (int)x;
}
template <typename T, typename... T1>
inline int read(T& a, T1&... other) {
return read(a) + read(other...);
}
template <typename T, typename... T1>
inline void print(T a, T1... other) {
print(a), print(other...);
}
struct Fast_IO {
~Fast_IO() {
fwrite(obuf, p3 - obuf, 1, stdout);
}
} io;
template <typename T>
Fast_IO& operator>>(Fast_IO& io, T& b) {
return read(b), io;
}
template <typename T>
Fast_IO& operator<<(Fast_IO& io, T b) {
return print(b), io;
}
#define cout io
#define cin io
} // namespace fast_IO
namespace temp {
int fac[N2] = {0};
il void Cinit(int p) {
fac[0] = 1;
for (int i = 1; i < N2; i++) {
fac[i] = fac[i - 1] * i % p;
}
}
il int qpow(int a, int b, int p) {
int ans = 1;
while (b) {
if (b & 1) {
ans = ans * a % p;
}
a = a * a % p;
b >>= 1;
}
return ans;
}
il int C(int n, int m, int p) {
if (m > n || m < 0) {
return 0;
}
return fac[n] * qpow(fac[m], p - 2, p) % p * qpow(fac[n - m], p - 2, p) % p;
}
il int Lucas(int n, int m, int p) {
if (!m)
return 1;
return (C(n % p, m % p, p) * Lucas(n / p, m / p, p)) % p;
}
il int GCD(int n, int m, int p) {
return __gcd(n, m) % p;
}
il int LCM(int n, int m, int p) {
return n * m % p * qpow(GCD(n, m, p), p - 2, p) % p;
}
} // namespace temp
//-----------------------------------------------------------------------------------------------//
using namespace fast_IO;
#define debug 1
// #define multi_test_ 1
#define endl '\n'
int _test_ = 1;
namespace zqh {
const int N = 200005;
int n, q, fa[N];
vector<int> g[N];
struct node {
int bmax;
int b_max;
int b__max;
int lmax, l_max, l__max, lmax_;
int fht, tch;
node() {
bmax = b__max = b_max = -1;
fht = tch = lmax = l_max = l__max = lmax_ = 0;
}
} b[N];
void dfs(int u) {
if (!u) return;
if (g[u].empty()) {
b[u].bmax = b[u].fht;
b[u].lmax = b[u].tch;
return;
}
vector<int> q, p;
// cout << "hmz AK IOI\n";
q.push_back(b[u].fht);
for (int x : g[u]) {
dfs(x);
q.push_back(b[x].bmax);
q.push_back(b[x].b_max);
q.push_back(b[x].b__max);
p.push_back(b[x].lmax);
}
p.push_back(b[u].tch);
sort(p.begin(), p.end(), greater<int>());
sort(q.begin(), q.end(), greater<int>());
b[u].lmax_ = p[1];
b[u].lmax = p[0];
b[u].bmax = q[0];
b[u].b_max = q[1];
b[u].b__max = q[2];
}
int get_l_max(int u) {
if (b[u].l_max) return b[u].l_max;
if (u == 1) {
return b[u].l_max = 0;
}
int t = fa[u];
int ans = b[t].tch;
for (int x : g[t]) {
if (x == u) continue;
ans = max(ans, b[x].lmax);
ans = max(ans, b[x].lmax_);
}
b[u].l_max = max(ans, get_l_max(t));
return b[u].l_max;
}
int get_l__max(int u) {
if (b[u].l__max) return b[u].l__max;
if (u == 1) {
return b[u].l__max = 0;
}
int t = fa[u];
vector<int> q;
q.push_back(b[t].tch);
for (int x : g[t]) {
if (x == u) continue;
q.push_back(b[x].lmax);
q.push_back(b[x].lmax_);
// ans = max(ans, b[x].lmax);
}
q.push_back(get_l_max(t));
q.push_back(get_l__max(t));
sort(q.begin(), q.end(), greater<int>());
b[u].l__max = q[1];
return b[u].l__max;
}
void calc_l_max() {
rep (i, 1, n) {
if (g[i].empty())
get_l_max(i);
}
}
void calc_l__max() {
rep (i, 1, n) {
if (g[i].empty())
get_l__max(i);
}
}
int dfs3(int u, int max_) {
int ans = 0;
if (b[u].fht != max_) {
ans = b[u].fht;
}
for (int x : g[u]) {
ans = max(ans, dfs3(x, max_));
}
return ans;
}
void init() {
cin >> n >> q;
rep (i, 2, n) {
cin >> fa[i];
g[fa[i]].push_back(i);
}
rep (i, 1, n) {
cin >> b[i].fht >> b[i].tch;
}
}
void solve() {
dfs(1);
calc_l_max();
calc_l__max();
// rep (i, 1, n) {
// cout << b[i].bmax << " " << b[i].b_max << " " << b[i].b__max << " " << b[i].l_max << " " << b[i].l__max << " " << b[i].lmax << endl;
// }
while (q--) {
int s;
cin >> s;
// cout << "[" << b[s].bmax << " " << b[s].b_max << " " << b[s].b__max << "]\n";
int l = b[s].l_max;
// cout << l << endl;
if (b[s].b_max == -1) {
cout << "0\n";
continue;
}
if (b[s].b__max == -1) {
cout << min(l + b[s].b_max, b[s].bmax) << endl;
continue;
}
if (l == 0 && b[s].bmax == b[s].b_max && b[s].b__max == b[s].bmax) {
cout << dfs3(s, b[s].bmax) << endl;
continue;
}
if (l + b[s].b_max > b[s].bmax) {
cout << b[s].bmax << endl;
continue;
}
if (l + b[s].b_max < b[s].bmax) {
cout << l + b[s].b_max << endl;
continue;
}
// cout << b[s].l__max << endl;
if (b[s].b__max != b[s].b_max) {
int ans = min(b[s].bmax, b[s].b__max + l);
if (b[s].b_max + b[s].l__max > b[s].bmax) ans = max(b[s].bmax, ans);
else if (b[s].b_max + b[s].l__max < b[s].bmax) ans = max(b[s].b_max + b[s].l__max, ans);
cout << ans << endl;
} else {
cout << min(b[s].bmax, b[s].b_max + b[s].l__max) << endl;
}
}
}
void main() {
init();
solve();
}
} // namespace zqh
signed main() {
// ios::sync_with_stdio(0);
// cin.tie(0);
// cout.tie(0);
#ifdef debug
// freopen("soldier1.in", "r", stdin);
// freopen("soldier.out", "w", stdout);
#endif
#ifdef multi_test_
cin >> _test_;
#endif
while (_test_--) {
zqh::main();
}
return 0;
}
/*
*/
TengMax LV 4
Jtwd2
