#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<ll, ll> pii;

namespace IO {
    char ibuf[1 << 17], *iS, *iT, obuf[1 << 17], *oS = obuf;
#define writesp(x) write(x), pc(' ')
#define writeln(x) write(x), pc('\n')
#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, 1 << 17, stdin), (iS == iT ? EOF : *iS++) : *iS++)
	template<typename T = int>
	inline T read () {
		char ch = gh();
		T x = 0;
		bool t = 0;
		while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
		while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gh();
		return t ? ~(x - 1) : x;
	}
	inline void flush () {
		fwrite(obuf, 1, oS - obuf, stdout), oS = obuf;
	}
	inline void pc (char ch) {
		if (oS == obuf + (1 << 17)) flush(); 
		*oS++ = ch;
	}
	template<typename T>
	inline void write (T x) {
		static char stk[64], *tp = stk;
		if (x < 0) {
			x = ~(x - 1);
			pc('-');
		}
		do {
			*tp++ = x % 10;
			x /= 10;
		} while (x);
		while (tp != stk) {
			pc((*--tp) | 48);
		}
	}
}

using IO::read;
using IO::write;
using IO::pc;
using IO::flush;

struct i24 {
	unsigned char a, b, c;
	
	i24(int x = 0) {
		a = x & 255;
		b = (x >> 8) & 255;
		c = (x >> 16) & 255;
	}
	
	inline int val() {
		return a + ((int)b << 8) + ((int)c << 16);
	}
};

const int maxn = 2000100;

int n, len;
i24 hd[maxn], to[maxn], nxt[maxn];

inline void add_edge(int u, int v) {
	to[++len] = v;
	nxt[len] = hd[u];
	hd[u] = len;
}

namespace BIT {
	int c[(1 << 21) + 50];
	
	inline void update(int x, int d) {
		for (int i = (++x); i < (1 << 21); i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline void clear(int x) {
		for (int i = (++x); i < (1 << 21); i += (i & (-i))) {
			c[i] = 0;
		}
	}
	
	inline int query(int x) {
		int res = 0;
		for (int i = (++x); i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
	
	inline int query(int l, int r) {
		return query(r) - query(l - 1);
	}
}

int top, tag, ans;
i24 stk[maxn], f[maxn], son[maxn], g[maxn], h[maxn];
bitset<maxn> vis;

inline int query(int x) {
	int ans = 0, l = 0, r = (1 << 21) - 1;
	for (int i = 20; ~i; --i) {
		int mid = (l + r) >> 1;
		if (x & (1 << i)) {
			if (BIT::query(mid + 1, r) == r - mid) {
				ans |= (1 << i);
				r = mid;
			} else {
				l = mid + 1;
			}
		} else {
			if (BIT::query(l, mid) == mid - l + 1) {
				ans |= (1 << i);
				l = mid + 1;
			} else {
				r = mid;
			}
		}
	}
	return ans;
}

inline void add(int x) {
	if (!vis.test(x)) {
		stk[++top] = x;
		BIT::update(x, 1);
	}
	vis.set(x);
}

inline void clear() {
	for (int i = 1; i <= top; ++i) {
		BIT::clear(stk[i].val());
		vis.reset(stk[i].val());
	}
	top = tag = 0;
}

int top_, stk_[maxn], it_[maxn], dfn[maxn], dfc, sz[maxn], rnk[maxn], p[maxn], fa[maxn];

inline void dfs_init() {
	for (int i = 1; i <= n; ++i) {
		it_[i] = hd[i].val();
	}
}

inline void sim_dfs() {
	dfs_init();
	stk_[top_ = 1] = 1;
	dfn[1] = dfc = 1;
	rnk[1] = 1;
	while (top_) {
		int u = stk_[top_];
		if (!it_[u]) {
			--top_;
			continue;
		}
		if (!vis.test(u)) {
			vis.set(u);
			stk_[++top_] = son[u].val();
			dfn[son[u].val()] = ++dfc;
			rnk[dfc] = son[u].val();
			continue;
		}
		int _ = it_[u];
		int v = to[_].val();
		it_[u] = nxt[_].val();
		if (v == son[u].val()) {
			continue;
		}
		stk_[++top_] = v;
		dfn[v] = ++dfc;
		rnk[dfc] = v;
	}
	for (int i = 1; i <= n; ++i) {
		vis.reset(i);
	}
}

void solve() {
	n = read();
	len = 0;
	for (int i = 1; i <= n; ++i) {
		hd[i] = 0;
		p[i] = 0;
	}
	for (int i = 2, p; i <= n; ++i) {
		p = read();
		add_edge(p, i);
		fa[i] = p;
	}
	for (int u = n; u; --u) {
		sz[u] = 1;
		son[u] = 0;
		for (int _ = hd[u].val(); _; _ = nxt[_].val()) {
			int v = to[_].val();
			sz[u] += sz[v];
			if (sz[v] > sz[son[u].val()]) {
				son[u] = v;
			}
		}
	}
	sim_dfs();
	for (int _ = n; _; --_) {
		int u = rnk[_];
		tag ^= p[u];
		p[u] ^= f[son[u].val()].val();
		for (int _ = hd[u].val(); _; _ = nxt[_].val()) {
			int v = to[_].val();
			if (v == son[u].val()) {
				continue;
			}
			int X = h[v].val() ^ p[u] ^ f[v].val() ^ tag;
			for (int i = dfn[v]; i < dfn[v] + sz[v]; ++i) {
				int w = rnk[i];
				g[w] = g[w].val() ^ X;
				add(g[w].val());
			}
		}
		g[u] = p[u] ^ tag;
		add(p[u] ^ tag);
		f[u] = query(tag);
		if (u != 1 && son[fa[u]].val() != u) {
			p[fa[u]] ^= f[u].val();
			h[u] = tag;
			clear();
		}
	}
	ans ^= f[1].val();
	clear();
}

int main() {
	int T = read();
	while (T--) {
		solve();
	}
	writeln(ans);
	flush();
	return 0;
}