```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

var scanner *bufio.Scanner
var out *bufio.Writer

func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024), 10*1024*1024)
	scanner.Split(bufio.ScanWords)
	out = bufio.NewWriter(os.Stdout)
}

func scanInt() int {
	scanner.Scan()
	b := scanner.Bytes()
	res := 0
	for _, v := range b {
		if v >= '0' && v <= '9' {
			res = res*10 + int(v-'0')
		}
	}
	return res
}

func solve() {
	n := scanInt()

	p := make([]int, n+1)
	children := make([][]int, n+1)
	roots := make([]int, 0)

	for i := 1; i <= n; i++ {
		p[i] = scanInt()
		if p[i] == 0 {
			roots = append(roots, i)
		} else {
			children[p[i]] = append(children[p[i]], i)
		}
	}

	S := make([][]int, n+1)
	mex_set := make([]map[int]bool, n+1)
	mex_val := make([]int, n+1)
	rank := make([]int, n+1)

	var dfs func(int)
	dfs = func(v int) {
		if len(children[v]) == 0 {
			rank[v] = 1
			S[v] = make([]int, 0, 1)
			mex_set[v] = map[int]bool{0: true}
			mex_val[v] = 1
			S[v] = append(S[v], 1)
			return
		}

		if len(children[v]) == 1 {
			c := children[v][0]
			dfs(c)
			rank[v] = rank[c] + 1
			S[v] = S[c]
			mex_set[v] = mex_set[c]
			mex_val[v] = mex_val[c]

			mex_set[v][S[v][len(S[v])-1]] = true
			for mex_set[v][mex_val[v]] {
				mex_val[v]++
			}
			S[v] = append(S[v], mex_val[v])
			return
		}

		hc := -1
		max_h := -1
		for _, c := range children[v] {
			dfs(c)
			if len(S[c]) > max_h {
				max_h = len(S[c])
				hc = c
			}
		}

		rank[v] = 1 << 30
		for _, c := range children[v] {
			if rank[c]+1 < rank[v] {
				rank[v] = rank[c] + 1
			}
		}

		S[v] = S[hc]
		for _, c := range children[v] {
			if c != hc {
				for i := 1; i <= len(S[c]); i++ {
					S[v][len(S[v])-i] ^= S[c][len(S[c])-i]
				}
			}
		}

		mex_set[v] = make(map[int]bool)
		for d := 1; d <= rank[v]; d++ {
			val := 0
			if d <= len(S[v]) {
				val = S[v][len(S[v])-d]
			}
			mex_set[v][val] = true
		}

		mex_val[v] = 0
		for mex_set[v][mex_val[v]] {
			mex_val[v]++
		}

		S[v] = append(S[v], mex_val[v])
	}

	ans := 0
	for _, r := range roots {
		dfs(r)
		ans ^= S[r][len(S[r])-1]
	}

	if ans > 0 {
		fmt.Fprintln(out, "YES")
	} else {
		fmt.Fprintln(out, "NO")
	}
}

func main() {
	if !scanner.Scan() {
		return
	}
	b := scanner.Bytes()
	t := 0
	for _, v := range b {
		if v >= '0' && v <= '9' {
			t = t*10 + int(v-'0')
		}
	}
	for i := 0; i < t; i++ {
		solve()
	}
	out.Flush()
}
```