#include <bits/stdc++.h>

#define ll long long
#define str string
#define endl '\n'
#define pb push_back
#define Mask(i, j) (i & (1 << j))
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define foru(c, a, b)  for(ite_type c = a; c <= b; ++c)
#define ford(c, a, b)  for(ite_type c = a; c >= b; --c)
#define faster ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define file(x, sur) if(fopen((x + ".inp").c_str(), "r")) \
                        freopen((x + ".inp").c_str(), "r", stdin), \
                        freopen((x + sur).c_str(), "w", stdout);

using namespace std;

mt19937_64 rd(chrono::steady_clock::now().time_since_epoch().count());

ll Rand(ll l, ll r) {
    return l + rd() % (r - l + 1);
}

const str name = "not_yet_defined";
typedef int ite_type;
typedef __int128 i128;
typedef pair<int, int> pii;

const bool is_file = 0, is_making_ans = 0;
const int ntest = 200;
const int maxn = 5e5 + 9, lim = 1e3, max_ai = 1e4;
const ll inf = 1e18, int_inf = 0x3f3f3f3f;
const int dx[] = {-2, -2, -1, -1, 1, 1, 2, 2},
          dy[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int mod = 998244353;

i128 extended_euclid(__int128 a, __int128 b, __int128& x, __int128& y) {
   if(!b) {
      x = 1, y = 0;
      return a;
   }
   i128 tmp = extended_euclid(b, a % b, x, y);
   i128 c = x;
   x = y;
   y = c - (a / b) * y;
   return tmp;
}

pair<i128, i128> crt(pair<i128, i128> a, pair<i128, i128> b) {
   if(a.fi < b.fi) swap(a, b);
   if(b.fi == 1) return a;
   i128 x, y;
   i128 gcd = extended_euclid(a.fi, b.fi, x, y);
   if((b.se - a.se) % gcd)
      return {-1, -1};
   i128 lcm = a.fi / gcd * b.fi;
   i128 ans = (x * (b.se - a.se) / gcd * a.fi + a.se) % lcm;
   if(ans < 0) ans += lcm;
   if(ans > 1e18) return {-1, -1};
   return {lcm, ans};
}

struct leaves {
   i128 m, r;
   int id;
};

vector<pii> graph[maxn];
vector<int> ct[maxn];
pair<i128, i128> req[maxn];
int par[maxn] = {}, ss[maxn], del[maxn], is_leaf[maxn];
ll path[maxn];

void dfs(int u, int p, pair<i128, i128> cur, ll sum = 0) {
   if(cur.fi == -1) return;
   path[u] = sum;
   req[u] = cur;

   int cnt = 0;
   for(pii v : graph[u])
      if(v.fi != p) {
         int mod = int(graph[u].size()) - (u != 1);
         pii nxt = {mod, (cnt++ - sum) % mod};
         if(nxt.se < 0) nxt.se += mod;
         pair<i128, i128> burb = crt(cur, nxt);

         dfs(v.fi, u, burb, sum + v.se);
      }
}


void compute_size(int u, int p) {
   ss[u] = 1;
   for(auto[v, w] : graph[u])
      if(v != p && !del[v])
         compute_size(v, u), ss[u] += ss[v];
}

int find_centroid(int u, int p, int n) {
   for(auto[v, w] : graph[u])
      if(v != p && !del[v] && ss[v] > n / 2)
         return find_centroid(v, u, n);
   return u;
}

int init(int u) {
   compute_size(u, 0);
   u = find_centroid(u, 0, ss[u]);
   del[u] = 1;
   for(auto[v, w] : graph[u])
      if(!del[v] && v != par[u])
         ct[u].pb(init(v));
      else if(v != par[u]) ct[u].pb(0);
   if(!del[par[u]] && u != 1) par[u] = init(par[u]);
   return u;
}

bool check(ll x, pair<i128, i128> p) {
   return x % p.fi == p.se;
}

int vis[maxn] = {};

int special_binary_search(ll x, int root) {
   vector<int> order;
   int ans = root;
   while(!(is_leaf[ans])) {
//      assert(!vis[ans]);
//      if(!ans) cout << order.back() << endl;
      vis[ans] = 1;
      order.pb(ans);
//      assert(ans);
      if(check(x, req[ans]))
         ans = ct[ans][(path[ans] + x) % (int(ct[ans].size()))];
      else ans = par[ans];
   }
   for(int e : order)
      vis[e] = 0;
   return ans;
}

void solve() {
   int n, m; cin >> n >> m;
   foru(i, 1, n) graph[i].clear(), ct[i].clear(), req[i] = {-1, -1}, del[i] = 0;

   vector<pii> edges(n + 1);
   foru(i, 2, n) cin >> edges[i].fi, par[i] = edges[i].fi;
   foru(i, 2, n) cin >> edges[i].se;
   foru(i, 2, n) graph[edges[i].fi].pb({i, edges[i].se}),
                 graph[i].pb({edges[i].fi, edges[i].se});
   foru(i, 2, n)
      is_leaf[i] = (graph[i].size() == 1), sort(all(graph[i]));

   dfs(1, 0, {1, 0});
   int root = init(1);

   vector<int> ans;
   while(m--) {
      ll x; cin >> x;
      if(n == 1)
         ans.pb(1);
      else ans.pb(special_binary_search(x, root));
   }
   for(int a : ans)
      cout << a << ' ';
   cout << endl;
}

int main() {
   ios_base::sync_with_stdio(0); cin.tie(0);
   file(name, ".out");
   //file and ios boost

   int t; cin >> t;
   while(t--)
      solve();
}