#include <bits/stdc++.h>
#define l(k) (k << 1)
#define r(k) (k << 1 | 1)
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;

const int N = 2e5 + 10;
int ta[N << 2], tab[N << 2], tabc[N << 2];
int lazya[N << 2], lazyb[N << 2], lazyc[N << 2];
int d[N], fa[N], top[N], id[N], siz[N], son[N], cnt;
vector<int> g[N];
vector<pair<int, int>> A, B, C;
int n, q;

void dfs1(int u, int father)
{
	d[u] = d[father] + 1;
	fa[u] = father;
	siz[u] = 1;
	for(int v: g[u])
	{
		dfs1(v, u);
		siz[u] += siz[v];
		if(siz[son[u]] < siz[v]) son[u] = v;
	}
}

void dfs2(int u, int fa, int t)
{
	top[u] = t;
	id[u] = ++cnt;
	
	if(siz[u] == 1) return;
	dfs2(son[u], u, t);

	for(int v: g[u])
	{
		if(v == fa || v == son[u]) continue;
		dfs2(v, u, v);
	}
}

void add(int u, int v, int op)
{
	while(top[u] != top[v])
	{
		if(d[top[u]] < d[top[v]]) swap(u, v);
		if(!op) A.push_back({id[top[u]], id[u]});
		else B.push_back({id[top[u]], id[u]});
		u = fa[top[u]];
	}
	if(d[u] < d[v]) swap(u, v);
	if(!op) A.push_back({id[v], id[u]});
	else B.push_back({id[v], id[u]});
}

void updateA(int k, int l, int r)
{
	ta[k] = r - l + 1;
	lazya[k] = 1;
}

void updateB(int k, int l, int r)
{
	tab[k] = ta[k];
	lazyb[k] = 1;
}

void updateC(int k, int l, int r)
{
	tabc[k] = tab[k];
	lazyc[k] = 1;
}

void up(int k)
{
	ta[k] = ta[l(k)] + ta[r(k)];
	tab[k] = tab[l(k)] + tab[r(k)];
	tabc[k] = tabc[l(k)] + tabc[r(k)];
}

void down(int k, int l, int r)
{
	int m = l + r >> 1;
	if(lazya[k]) updateA(l(k), l, m), updateA(r(k), m + 1, r), lazya[k] = 0; 
	if(lazyb[k]) updateB(l(k), l, m), updateB(r(k), m + 1, r), lazyb[k] = 0; 
	if(lazyc[k]) updateC(l(k), l, m), updateC(r(k), m + 1, r), lazyc[k] = 0; 
}

void change(int k, int l, int r, int L, int R, int op)
{
	if(L <= l && r <= R)
	{
		if(!op) updateA(k, l, r);
		else if(op == 1) updateB(k, l, r);
		else updateC(k, l, r);
		return;
	}
	down(k, l, r);
	int m = l + r >> 1;
	if(L <= m) change(l(k), l, m, L, R, op);
	if(R > m) change(r(k), m + 1, r, L, R, op);
	up(k);
}

void Clear(int k, int l, int r, int L, int R)
{
	if(L <= l && r <= R)
	{
		ta[k] = tab[k] = tabc[k] = lazya[k] = lazyb[k] = lazyc[k] = 0;
		return;
	}
	down(k, l, r);
	int m = l + r >> 1;
	if(L <= m) Clear(l(k), l, m, L, R);
	if(R > m) Clear(r(k), m + 1, r, L, R);
}
 
int main()
{
	int T; scanf("%d", &T);
	while(T--)
	{
		scanf("%d%d", &n, &q);
		_for(i, 1, n) g[i].clear(), son[i] = d[i] = top[i] = fa[i] = id[i] = 0;
		cnt = 0;
		_for(i, 2, n)
		{
			int x; scanf("%d", &x);
			g[x].push_back(i);
		}

		dfs1(1, 0);
		dfs2(1, 0, 1);

		while(q--)
		{
			A.clear(); B.clear(); C.clear();

			int na, nb, nc, x;
			scanf("%d%d%d", &na, &nb, &nc);
			while(na--)
			{
				scanf("%d", &x);
				add(1, x, 0);
			}
			while(nb--)
			{
				scanf("%d", &x);
				add(1, x, 1);
			}
			while(nc--)
			{
				scanf("%d", &x);
				C.push_back({id[x], id[x] + siz[x] - 1});
			}

			for(auto [l, r]: A) change(1, 1, n, l, r, 0);
			for(auto [l, r]: B) change(1, 1, n, l, r, 1);
			for(auto [l, r]: C) change(1, 1, n, l, r, 2);
			printf("%d\n", tabc[1]);

			for(auto [l, r]: A) Clear(1, 1, n, l, r);
			for(auto [l, r]: B) Clear(1, 1, n, l, r);
			for(auto [l, r]: C) Clear(1, 1, n, l, r);
		}
	}

    return 0;
}