#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e6 + 5;

int ans, K;
int rt[maxn], son[maxn];

struct edge
{
    int v, next;
}e[maxn];
int head[maxn], tot;

inline void addedge(int u, int v) { e[++tot] = (edge){v, head[u]}, head[u] = tot; }

void dfs(int u)
{
	rt[u] = 1, son[u] = 0;
	for (int i = head[u]; i; i = e[i].next)
	{
        int v = e[i].v; dfs(v), rt[u] += rt[v];
		if (rt[v] > rt[son[u]]) son[u] = v;
	}
}

struct trie
{
	struct trinode
	{
		int ls, rs;
		int siz, dep, lz;
	}t[maxn << 1];
	int stk[maxn << 1], tp, cnt;
	
	inline int newnod(int d)
	{
		int x = tp ? stk[tp--] : ++cnt;
		t[x].dep = d; return x;
	}
	inline void recycle(int x)
	{
		stk[++tp] = x;
		t[x].ls = t[x].rs = t[x].siz = t[x].dep = t[x].lz = 0;
	}
	
	inline void pushup(int k) { t[k].siz = t[t[k].ls].siz + t[t[k].rs].siz; }
	inline void upd(int k, int d) { t[k].lz ^= d; if (t[k].dep && ((d >> (t[k].dep - 1)) & 1)) swap(t[k].ls, t[k].rs); }
	inline void pushdown(int k) { if (t[k].lz) upd(t[k].ls, t[k].lz), upd(t[k].rs, t[k].lz), t[k].lz = 0; }
	
	int query(int k, int dep)
	{
		if (!k || !dep) return 0;
		pushdown(k);
		if (t[t[k].ls].siz == (1 << (dep - 1))) return (1 << (dep - 1)) + query(t[k].rs, dep - 1);
		else return query(t[k].ls, dep - 1);
	}
	
	int merge(int a, int b, int dep)
	{
		if (!a || !b) return a ^ b;
		if (!dep)
		{
			t[a].siz |= t[b].siz;
			recycle(b); return a;
		}
		pushdown(a), pushdown(b);
		t[a].ls = merge(t[a].ls, t[b].ls, dep - 1);
		t[a].rs = merge(t[a].rs, t[b].rs, dep - 1);
		recycle(b); pushup(a); return a;
	}
	
	void insert(int &k, int dep, int x)
	{
		if (!k) k = newnod(dep);
		if (!dep) return t[k].siz = 1, void();
		pushdown(k);
		if ((x >> (dep - 1)) & 1) insert(t[k].rs, dep - 1, x);
		else insert(t[k].ls, dep - 1, x);
		pushup(k);
	}
}T;

int dfs2(int u)
{
	int sum = 0; rt[u] = 0;
	if (son[u])
	{
		sum ^= dfs2(son[u]);
		rt[u] = rt[son[u]];
	}
	for (int i = head[u]; i; i = e[i].next)
    {
        int v = e[i].v;
		if (v != son[u])
		{
			int sg = dfs2(v); T.upd(rt[u], sg), T.upd(rt[v], sum);
			sum ^= sg, rt[u] = T.merge(rt[u], rt[v], K);
		}
    }
	T.insert(rt[u], K, sum); return T.query(rt[u], K);
}

void work()
{
	int n; cin >> n; T.cnt = T.tp = K = 0;
	while ((1 << K) <= n) K++;
    for (int i = 1; i <= n; i++) head[i] = 0; tot = 0;
	for (int i = 2; i <= n; i++)
	{
		int x; cin >> x;
        addedge(x, i);
	}
	dfs(1); ans ^= dfs2(1);
	for (int i = 1; i <= T.cnt; i++) T.recycle(i);
}

int main()
{
	ios::sync_with_stdio(false), cin.tie(0);
	
	int T; cin >> T;
	while (T--) work();
	cout << ans;
	return 0;
}