```go
package main

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

type Basis struct {
	mask [30]int32
	idx  [30]int32
}

type SimpleBasis struct {
	mask [30]int32
}

func insert(b *Basis, val int32, index int32) {
	for i := 29; i >= 0; i-- {
		if (val & (1 << i)) != 0 {
			if b.mask[i] == 0 {
				b.mask[i] = val
				b.idx[i] = index
				break
			}
			if b.idx[i] < index {
				b.mask[i], val = val, b.mask[i]
				b.idx[i], index = index, b.idx[i]
			}
			val ^= b.mask[i]
		}
	}
}

func insertSimple(b *SimpleBasis, val int32) {
	for i := 29; i >= 0; i-- {
		if (val & (1 << i)) != 0 {
			if b.mask[i] == 0 {
				b.mask[i] = val
				break
			}
			val ^= b.mask[i]
		}
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	const maxCapacity = 10 * 1024 * 1024
	buf := make([]byte, maxCapacity)
	scanner.Buffer(buf, maxCapacity)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res := 0
		sign := 1
		for _, b := range scanner.Bytes() {
			if b == '-' {
				sign = -1
			} else {
				res = res*10 + int(b-'0')
			}
		}
		return res * sign
	}

	if !scanner.Scan() {
		return
	}
	resT := 0
	for _, b := range scanner.Bytes() {
		resT = resT*10 + int(b-'0')
	}
	t := resT

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for tc := 0; tc < t; tc++ {
		n := readInt()
		a := make([]int32, n+1)
		for i := 1; i <= n; i++ {
			a[i] = int32(readInt())
		}

		adj := make([][]int32, n+1)
		for i := 1; i < n; i++ {
			u := int32(readInt())
			v := int32(readInt())
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		in := make([]int32, n+1)
		outDFS := make([]int32, n+1)
		depth := make([]int32, n+1)
		up := make([][20]int32, n+1)
		timer := int32(0)

		var dfs func(v, p, d int32)
		dfs = func(v, p, d int32) {
			timer++
			in[v] = timer
			depth[v] = d
			up[v][0] = p
			for i := 1; i < 20; i++ {
				if up[v][i-1] != 0 {
					up[v][i] = up[up[v][i-1]][i-1]
				} else {
					up[v][i] = 0
				}
			}
			for _, u := range adj[v] {
				if u != p {
					dfs(u, v, d+1)
				}
			}
			outDFS[v] = timer
		}
		dfs(1, 0, 0)

		arr := make([]int32, n+1)
		for i := int32(1); i <= int32(n); i++ {
			arr[in[i]] = a[i]
		}

		prefBasis := make([]Basis, n+1)
		for i := int32(1); i <= int32(n); i++ {
			prefBasis[i] = prefBasis[i-1]
			insert(&prefBasis[i], arr[i], i)
		}

		prefSimple := make([]SimpleBasis, n+2)
		for i := int32(1); i <= int32(n); i++ {
			prefSimple[i] = prefSimple[i-1]
			insertSimple(&prefSimple[i], arr[i])
		}

		suffSimple := make([]SimpleBasis, n+2)
		for i := int32(n); i >= 1; i-- {
			suffSimple[i] = suffSimple[i+1]
			insertSimple(&suffSimple[i], arr[i])
		}

		q := readInt()
		for i := 0; i < q; i++ {
			r := int32(readInt())
			v := int32(readInt())

			if r == v {
				ans := int32(0)
				for j := 29; j >= 0; j-- {
					if (ans ^ prefSimple[n].mask[j]) > ans {
						ans ^= prefSimple[n].mask[j]
					}
				}
				fmt.Fprintln(out, ans)
			} else if in[v] <= in[r] && outDFS[r] <= outDFS[v] {
				curr := r
				targetDepth := depth[v] + 1
				for j := 19; j >= 0; j-- {
					if depth[curr]-(1<<j) >= targetDepth {
						curr = up[curr][j]
					}
				}
				u := curr

				b := prefSimple[in[u]-1]
				for j := 29; j >= 0; j-- {
					if suffSimple[outDFS[u]+1].mask[j] != 0 {
						insertSimple(&b, suffSimple[outDFS[u]+1].mask[j])
					}
				}
				ans := int32(0)
				for j := 29; j >= 0; j-- {
					if (ans ^ b.mask[j]) > ans {
						ans ^= b.mask[j]
					}
				}
				fmt.Fprintln(out, ans)
			} else {
				ans := int32(0)
				for j := 29; j >= 0; j-- {
					if prefBasis[outDFS[v]].idx[j] >= in[v] {
						if (ans ^ prefBasis[outDFS[v]].mask[j]) > ans {
							ans ^= prefBasis[outDFS[v]].mask[j]
						}
					}
				}
				fmt.Fprintln(out, ans)
			}
		}
	}
}
```