package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

var buf []byte
var pos int

func nextInt() int {
	for pos < len(buf) && buf[pos] <= ' ' {
		pos++
	}
	if pos >= len(buf) {
		return 0
	}
	res := 0
	sign := 1
	if buf[pos] == '-' {
		sign = -1
		pos++
	}
	for pos < len(buf) && buf[pos] > ' ' {
		res = res*10 + int(buf[pos]-'0')
		pos++
	}
	return res * sign
}

var tree [20][2][]int

func init() {
	for k := 0; k < 20; k++ {
		tree[k][0] = make([]int, (1<<(k+1))+1)
		tree[k][1] = make([]int, (1<<(k+1))+1)
	}
}

func add(k, b, idx, val int) {
	idx++
	for ; idx < len(tree[k][b]); idx += idx & -idx {
		tree[k][b][idx] += val
	}
}

func querySum(k, b, idx int) int {
	idx++
	sum := 0
	for ; idx > 0; idx -= idx & -idx {
		sum += tree[k][b][idx]
	}
	return sum
}

func Query(k, b, L, R int) int {
	return querySum(k, b, R) - querySum(k, b, L-1)
}

func QueryCyclic(bit, b, L, R int) int {
	M := 1 << (bit + 1)
	L = (L%M + M) % M
	R = (R%M + M) % M
	if L <= R {
		return Query(bit, b, L, R)
	} else {
		return Query(bit, b, L, M-1) + Query(bit, b, 0, R)
	}
}

type Request struct {
	typ      int
	sign     int
	queryIdx int
	C        int
}

var adj [][]int
var a []int
var up [20][]int
var depth []int
var reqs [][]Request
var ans []int64

func dfsLCA(u, p, d int) {
	up[0][u] = p
	depth[u] = d
	for i := 1; i < 20; i++ {
		up[i][u] = up[i-1][up[i-1][u]]
	}
	for _, v := range adj[u] {
		if v != p {
			dfsLCA(v, u, d+1)
		}
	}
}

func getLCA(u, v int) int {
	if depth[u] < depth[v] {
		u, v = v, u
	}
	diff := depth[u] - depth[v]
	for i := 0; i < 20; i++ {
		if (diff & (1 << i)) != 0 {
			u = up[i][u]
		}
	}
	if u == v {
		return u
	}
	for i := 19; i >= 0; i-- {
		if up[i][u] != up[i][v] {
			u = up[i][u]
			v = up[i][v]
		}
	}
	return up[0][u]
}

func dfsSolve(u, p int) {
	for k := 0; k < 20; k++ {
		b := (a[u] >> k) & 1
		D := depth[u] % (1 << (k + 1))
		add(k, b, D, 1)
	}

	for _, req := range reqs[u] {
		var sum int64 = 0
		for k := 0; k < 20; k++ {
			M := 1 << (k + 1)
			C := (req.C%M + M) % M
			cnt := 0
			if req.typ == 1 {
				L0 := (C + 1) % M
				R0 := (C + (1 << k)) % M
				cnt += QueryCyclic(k, 0, L0, R0)

				L1 := (C + (1 << k) + 1) % M
				R1 := C % M
				cnt += QueryCyclic(k, 1, L1, R1)
			} else {
				L0 := ((1 << k) - C + M) % M
				R0 := (L0 + (1 << k) - 1) % M
				cnt += QueryCyclic(k, 0, L0, R0)

				L1 := (-C + M) % M
				R1 := (L1 + (1 << k) - 1) % M
				cnt += QueryCyclic(k, 1, L1, R1)
			}
			sum += int64(cnt) * int64(1<<k)
		}
		ans[req.queryIdx] += int64(req.sign) * sum
	}

	for _, v := range adj[u] {
		if v != p {
			dfsSolve(v, u)
		}
	}

	for k := 0; k < 20; k++ {
		b := (a[u] >> k) & 1
		D := depth[u] % (1 << (k + 1))
		add(k, b, D, -1)
	}
}

func main() {
	buf, _ = io.ReadAll(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := nextInt()
	if t == 0 {
		return
	}

	maxN := 500005
	adj = make([][]int, maxN)
	a = make([]int, maxN)
	for j := 0; j < 20; j++ {
		up[j] = make([]int, maxN)
	}
	depth = make([]int, maxN)
	reqs = make([][]Request, maxN)
	ans = make([]int64, 100005)

	for i := 0; i < t; i++ {
		n := nextInt()
		for j := 0; j <= n; j++ {
			adj[j] = adj[j][:0]
			reqs[j] = reqs[j][:0]
		}

		for j := 0; j < n-1; j++ {
			u, v := nextInt(), nextInt()
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		for j := 1; j <= n; j++ {
			a[j] = nextInt()
		}

		dfsLCA(1, 0, 0)

		q := nextInt()
		for j := 0; j < q; j++ {
			ans[j] = 0
		}

		for j := 0; j < q; j++ {
			x, y := nextInt(), nextInt()
			lca := getLCA(x, y)
			dist := depth[x] + depth[y] - 2*depth[lca]

			reqs[x] = append(reqs[x], Request{1, 1, j, depth[x]})
			reqs[up[0][lca]] = append(reqs[up[0][lca]], Request{1, -1, j, depth[x]})

			reqs[y] = append(reqs[y], Request{2, 1, j, dist - depth[y]})
			reqs[lca] = append(reqs[lca], Request{2, -1, j, dist - depth[y]})
		}

		dfsSolve(1, 0)

		var b []byte
		for j := 0; j < q; j++ {
			b = strconv.AppendInt(b[:0], ans[j], 10)
			b = append(b, '\n')
			out.Write(b)
		}
	}
}