package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) NextInt() int {
	sign := 1
	val := 0
	c, err := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, err = fs.r.ReadByte()
		if err != nil {
			return 0
		}
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c2, err := fs.r.ReadByte()
		if err != nil {
			break
		}
		c = c2
	}
	return sign * val
}

func writeInt(w *bufio.Writer, x int) {
	w.WriteString(strconv.Itoa(x))
}

func writeIntsLine(w *bufio.Writer, arr []int) {
	if len(arr) == 0 {
		w.WriteByte('\n')
		return
	}
	for i, v := range arr {
		if i > 0 {
			w.WriteByte(' ')
		}
		writeInt(w, v)
	}
	w.WriteByte('\n')
}

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

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

		cnt := make([]int, n+1)
		for i := 1; i <= n; i++ {
			if a1[i] >= 1 && a1[i] <= n {
				cnt[a1[i]]++
			}
			if a2[i] >= 1 && a2[i] <= n {
				cnt[a2[i]]++
			}
		}
		ok := true
		for v := 1; v <= n; v++ {
			if cnt[v] != 2 {
				ok = false
				break
			}
		}
		if !ok {
			out.WriteString("-1\n")
			continue
		}

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

		visited := make([]bool, n+1)
		res := make([]int, 0)

		for e := 1; e <= n; e++ {
			if visited[e] {
				continue
			}
			u0 := a1[e]
			v0 := a2[e]
			if u0 == v0 {
				visited[e] = true
				continue
			}
			edges := make([]int, 0, 4)
			verts := make([]int, 0, 4)

			visited[e] = true
			edges = append(edges, e)
			verts = append(verts, u0)

			prevEdge := e
			cur := v0

			for cur != u0 {
				verts = append(verts, cur)
				al := adj[cur]
				// al has length 2, pick the one not equal prevEdge
				var nextEdge int
				if al[0] != prevEdge {
					nextEdge = al[0]
				} else {
					nextEdge = al[1]
				}
				visited[nextEdge] = true
				p := a1[nextEdge]
				q := a2[nextEdge]
				var nextv int
				if p == cur {
					nextv = q
				} else {
					nextv = p
				}
				edges = append(edges, nextEdge)
				prevEdge = nextEdge
				cur = nextv
			}
			L := len(edges)
			forwardSwaps := 0
			for k := 0; k < L; k++ {
				if a1[edges[k]] != verts[k] {
					forwardSwaps++
				}
			}
			if forwardSwaps <= L-forwardSwaps {
				for k := 0; k < L; k++ {
					if a1[edges[k]] != verts[k] {
						res = append(res, edges[k])
					}
				}
			} else {
				for k := 0; k < L; k++ {
					tail := verts[(k+1)%L]
					if a1[edges[k]] != tail {
						res = append(res, edges[k])
					}
				}
			}
		}

		writeInt(out, len(res))
		out.WriteByte('\n')
		writeIntsLine(out, res)
	}
}