#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;

typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef long long ll;

template <typename _T>
inline void read(_T &f) {
    f = 0; _T fu = 1; char c = getchar();
    while (c < '0' || c > '9') { if (c == '-') { fu = -1; } c = getchar(); }
    while (c >= '0' && c <= '9') { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); }
    f *= fu;
}

template <typename T>
void print(T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x < 10) putchar(x + 48);
    else print(x / 10), putchar(x % 10 + 48);
}

template <typename T>
void print(T x, char t) {
    print(x); putchar(t);
}

const int N = 4e5 + 5;

struct seg_t {
    int lc[N * 20], rc[N * 20], val[N * 20];
    int tot;

    void reset() {
        for (int i = 1; i <= tot; i++) {
            lc[i] = rc[i] = val[i] = 0;
        }
        tot = 0;
    }

    void ins(int &u, int pre, int l, int r, int x, int y) {
        u = ++tot; lc[u] = lc[pre]; rc[u] = rc[pre];
        if (l == r) {
            val[u] = y;
            return;
        }
        int mid = (l + r) >> 1;
        if (mid >= x) ins(lc[u], lc[pre], l, mid, x, y);
        else ins(rc[u], rc[pre], mid + 1, r, x, y);
    }

    int query(int u, int l, int r, int x) {
        if (!u) return 0;
        if (l == r) return val[u];
        int mid = (l + r) >> 1;
        if (mid >= x) return query(lc[u], l, mid, x);
        return query(rc[u], mid + 1, r, x);
    }
} tr;

const ull base = 19260817;

ull h1[N], h2[N], pw[N];

map <int, int> son[N];
vector <pii> adj[N];
vector <int> ft[N], vec[N];
queue <int> q;
int fa[N], c[N], t[N], top[N], siz[N], wson[N], tops[N], pre[N], mx[N], lim[N], fail[N], rt[N], ans2[N], dep[N];
ll ans[N];
int T, n, m, dfnt;

void dfs1(int u) {
    siz[u] = 1; wson[u] = -1;
    for (auto v : adj[u]) {
        dep[v.first] = dep[u] + 1;
        dfs1(v.first);
        siz[u] += siz[v.first];
        if (wson[u] == -1 || siz[v.first] > siz[wson[u]]) wson[u] = v.first;
    }
}

void dfs2(int u, int tp) {
    tops[u] = ++dfnt; pre[dfnt] = u; top[u] = tp;
    mx[tp] = tops[u];
    if (wson[u] != -1) dfs2(wson[u], tp);
    for (auto v : adj[u]) {
        if (v.first == wson[u]) continue;
        dfs2(v.first, v.first);
    }
}

ull ghs1(int l, int r) {
    return h1[r] - h1[l - 1] * pw[r - l + 1];
}

ull ghs2(int l, int r) {
    return h2[r] - h2[l - 1] * pw[r - l + 1];
}

void dfs3(int u) {
    siz[u] = 1; tops[u] = ++dfnt;
    for (auto v : ft[u]) {
        dfs3(v);
        siz[u] += siz[v];
    }
}

struct node_t {
    int l, r, mn, mn2, cnt, tag;
    ll sum;
} p[N << 2];

void update(int u) {
    p[u].mn = min(p[u << 1].mn, p[u << 1 | 1].mn);
    p[u].sum = p[u << 1].sum + p[u << 1 | 1].sum;
    if (p[u << 1].mn == p[u << 1 | 1].mn) {
        p[u].mn2 = min(p[u << 1].mn2, p[u << 1 | 1].mn2);
        p[u].cnt = p[u << 1].cnt + p[u << 1 | 1].cnt;
    } else if (p[u << 1].mn < p[u << 1 | 1].mn) {
        p[u].mn2 = min(p[u << 1].mn2, p[u << 1 | 1].mn);
        p[u].cnt = p[u << 1].cnt;
    } else {
        p[u].mn2 = min(p[u << 1].mn, p[u << 1 | 1].mn2);
        p[u].cnt = p[u << 1 | 1].cnt;
    }
}

void add_tag(int u, int x) {
    if (x <= p[u].mn) return;
    p[u].sum += 1ll * (x - p[u].mn) * p[u].cnt;
    p[u].mn = p[u].tag = x;
}

void pushdown(int u) {
    if (p[u].tag) {
        add_tag(u << 1, p[u].tag);
        add_tag(u << 1 | 1, p[u].tag);
        p[u].tag = 0;
    }
}

void build(int u, int l, int r) {
    p[u].l = l; p[u].r = r; p[u].tag = 0; p[u].sum = 0;
    if (l == r) {
        p[u].mn = 0; p[u].mn2 = 1e9; p[u].cnt = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    update(u);
}

void modify(int u, int l, int r, int x) {
    if (p[u].mn >= x) return;
    if (l <= p[u].l && p[u].r <= r && p[u].mn2 > x) {
        add_tag(u, x);
        return;
    }
    pushdown(u);
    int mid = (p[u].l + p[u].r) >> 1;
    if (mid >= l) modify(u << 1, l, r, x);
    if (mid + 1 <= r) modify(u << 1 | 1, l, r, x);
    update(u);
}

int main() {
    read(T);
    while (T--) {
        dfnt = 0;
        read(n); read(m);
        for (int i = 0; i <= n; i++) adj[i].clear(), son[i].clear();
        for (int i = 1; i <= n; i++) read(fa[i]);
        for (int i = 1; i <= n; i++) {
            read(c[i]);
            adj[fa[i]].emplace_back(i, c[i]);
            son[fa[i]][c[i]] = i;
            // fprintf(stderr, "%d %d %d\n", fa[i], i, c[i]);
        }
        for (int i = 1; i <= m; i++) read(t[i]);
        dfs1(0); dfs2(0, 0);
        pw[0] = 1;
        for (int i = 1; i <= n + 1; i++) {
            pw[i] = pw[i - 1] * base;
            h1[i] = h1[i - 1] * base + c[pre[i]];
            h2[i] = h2[i - 1] * base + t[i];
        }
        for (int _ = 1; _ <= n; _++) {
            int u = _;
            lim[_] = 0;
            while (adj[u].size()) {
                int now = min(mx[top[u]] - tops[u], m - lim[_]);
                int l = 1, r = now, res = 0;
                while (l <= r) {
                    int mid = (l + r) >> 1;
                    if (ghs1(tops[u] + 1, tops[u] + mid) == ghs2(lim[_] + 1, lim[_] + mid)) res = mid, l = mid + 1;
                    else r = mid - 1;
                }
                lim[_] += res; u = pre[tops[u] + res];
                if (lim[_] == m) break;
                if (!son[u].count(t[lim[_] + 1])) break;
                ++lim[_];
                u = son[u][t[lim[_]]];
            }
            // fprintf(stderr, "lim[%d] = %d\n", _, lim[_]);
        }
        tr.reset();
        for (int i = 0; i <= n; i++) ft[i].clear();
        q.push(0); rt[0] = 0;
        while (!q.empty()) {
            int u = q.front(); q.pop();
            if (u) rt[u] = rt[fail[u]];
            for (auto v : adj[u]) tr.ins(rt[u], rt[u], 1, n, v.second, u);
            if (u) ft[fail[u]].push_back(u);
            for (auto v : adj[u]) {
                if (u == 0) {
                    fail[v.first] = 0;
                } else {
                    int tmp = tr.query(rt[fail[u]], 1, n, v.second);
                    if (son[tmp].count(v.second)) fail[v.first] = son[tmp][v.second];
                    else fail[v.first] = 0;
                }
                q.push(v.first);
            }
        }
        dfnt = 0; dfs3(0);
        int now = 0;
        for (int i = 1; i <= m; i++) {
            while (now && !son[now].count(t[i])) now = fail[now];
            if (son[now].count(t[i])) now = son[now][t[i]];
            ans2[i] = dep[now];
        }
        for (int i = 1; i <= m; i++) vec[i].clear();
        for (int i = 1; i <= n; i++) {
            if (lim[i]) vec[min(m, lim[i])].push_back(i);
        }
        build(1, 1, n);
        for (int i = m; i >= 1; i--) {
            for (auto j : vec[i]) {
                modify(1, tops[j] - 1, tops[j] + siz[j] - 2, dep[j]);
                // fprintf(stderr, "j = %d, cover [%d, %d] %d\n", j, tops[j] - 1, tops[j] + siz[j] - 2, dep[j]);
            }
            int cnt0 = p[1].mn == 0 ? p[1].cnt : 0;
            ans[i] = p[1].sum + 1ll * (n - cnt0) * i + 1ll * cnt0 * ans2[i];
        }
        for (int i = 1; i <= m; i++) print(ans[i], i == m ? '\n' : ' ');
    }
    return 0;
}