package main

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

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func dfs(root int, adj [][]int, parent, dist []int) {
	parent[root] = -1
	dist[root] = 0
	stack := make([]int, 1, len(adj)-1)
	stack[0] = root
	for len(stack) > 0 {
		v := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		pv := parent[v]
		dv := dist[v]
		for _, to := range adj[v] {
			if to == pv {
				continue
			}
			parent[to] = v
			dist[to] = dv + 1
			stack = append(stack, to)
		}
	}
}

func check(path []int, c, d []int) bool {
	for i := 0; i+1 < len(path); i++ {
		if d[path[i]] != c[path[i+1]] {
			return false
		}
	}
	return d[path[len(path)-1]] == c[path[0]]
}

func writeInt(w *bufio.Writer, x int) {
	var buf [20]byte
	b := strconv.AppendInt(buf[:0], int64(x), 10)
	w.Write(b)
}

func main() {
	fs := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := fs.NextInt()
	for ; t > 0; t-- {
		n := fs.NextInt()
		c := make([]int, n+1)
		d := make([]int, n+1)
		for i := 1; i <= n; i++ {
			c[i] = fs.NextInt()
		}
		for i := 1; i <= n; i++ {
			d[i] = fs.NextInt()
		}

		adj := make([][]int, n+1)
		for i := 0; i < n-1; i++ {
			x := fs.NextInt()
			y := fs.NextInt()
			adj[x] = append(adj[x], y)
			adj[y] = append(adj[y], x)
		}

		mism := make([]int, 0)
		for i := 1; i <= n; i++ {
			if c[i] != d[i] {
				mism = append(mism, i)
			}
		}

		if len(mism) == 0 {
			out.WriteString("Yes\n0\n")
			continue
		}

		parent0 := make([]int, n+1)
		dist0 := make([]int, n+1)
		dfs(mism[0], adj, parent0, dist0)

		a := mism[0]
		for _, x := range mism {
			if dist0[x] > dist0[a] {
				a = x
			}
		}

		parentA := make([]int, n+1)
		distA := make([]int, n+1)
		dfs(a, adj, parentA, distA)

		b := a
		for _, x := range mism {
			if distA[x] > distA[b] {
				b = x
			}
		}

		dfs(b, adj, parent0, dist0)

		diam := distA[b]
		ok := true
		for _, x := range mism {
			if distA[x]+dist0[x] != diam {
				ok = false
				break
			}
		}

		if !ok {
			out.WriteString("No\n")
			continue
		}

		rev := make([]int, 0, diam+1)
		u := b
		for {
			rev = append(rev, u)
			if u == a {
				break
			}
			u = parentA[u]
		}

		path := make([]int, len(rev))
		for i := 0; i < len(rev); i++ {
			path[i] = rev[len(rev)-1-i]
		}

		if !check(path, c, d) {
			for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
				path[i], path[j] = path[j], path[i]
			}
			if !check(path, c, d) {
				out.WriteString("No\n")
				continue
			}
		}

		out.WriteString("Yes\n")
		writeInt(out, len(path))
		out.WriteByte('\n')
		for i, v := range path {
			if i > 0 {
				out.WriteByte(' ')
			}
			writeInt(out, v)
		}
		out.WriteByte('\n')
	}
}