You are given a table $a$ of size $2 \times n$ (i.e. two rows and $n$ columns) consisting of integers from $1$ to $n$.

In one move, you can choose some column $j$ ($1 \le j \le n$) and swap values $a_{1, j}$ and $a_{2, j}$ in it. Each column can be chosen no more than once.

Your task is to find the minimum number of moves required to obtain permutations of size $n$ in both first and second rows of the table or determine if it is impossible to do that.

You have to answer $t$ independent test cases.

Recall that the permutation of size $n$ is such an array of size $n$ that contains each integer from $1$ to $n$ exactly once (the order of elements doesn't matter).


-----Input-----

The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.

The first line of the test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of columns in the table. The second line of the test case contains $n$ integers $a_{1, 1}, a_{1, 2}, \dots, a_{1, n}$ ($1 \le a_{1, i} \le n$), where $a_{1, i}$ is the $i$-th element of the first row of the table. The third line of the test case contains $n$ integers $a_{2, 1}, a_{2, 2}, \dots, a_{2, n}$ ($1 \le a_{2, i} \le n$), where $a_{2, i}$ is the $i$-th element of the second row of the table.

It is guaranteed that the sum of $n$ does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).


-----Output-----

For each test case print the answer: -1 if it is impossible to obtain permutation of size $n$ in both first and the second rows of the table, or one integer $k$ in the first line, where $k$ is the minimum number of moves required to obtain permutations in both rows, and $k$ distinct integers $pos_1, pos_2, \dots, pos_k$ in the second line ($1 \le pos_i \le n$) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.


-----Example-----
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2

Output
0

2
2 3 
1
1 
2
3 4 
2
3 4 
-1

Difficulty: introductory

Starter code:

Solutions:
import sys

sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def maketo():
    atoi=[[] for _ in range(n)]
    for i,a in enumerate(aa):
        if a<1 or a>n:return True
        atoi[a-1].append(i)
        if len(atoi[a-1])>2:return True
    for a in range(n):
        u,v=atoi[a]
        if u+n==v:continue
        to[u].append((v+n)%(n*2))
        to[v].append((u+n)%(n*2))
    return False

def dfs(u):
    flap[u%n]=(u>=n)*1
    cur[u>=n].append(u%n+1)
    stack=[u]
    while stack:
        u=stack.pop()
        for v in to[u]:
            if flap[v%n]==-1:
                flap[v % n]=(v>=n)*1
                cur[v >= n].append(v % n+1)
                stack.append(v)
            elif flap[v % n]!=(v>=n)*1:return True
    return False

for _ in range(II()):
    n=II()
    aa=LI()+LI()
    to=[[] for _ in range(n*2)]

    if maketo():
        print(-1)
        continue
    #print(to)

    ans = []
    flap=[-1]*n
    ng=False
    for u in range(n):
        #u+=n
        if flap[u%n]!=-1:continue
        cur=[[],[]]
        ng=dfs(u)
        if len(cur[0])<len(cur[1]):ans+=cur[0]
        else:ans+=cur[1]
        #print(u,flap,cur,ans)
        if ng:break

    if ng:print(-1)
    else:
        print(len(ans))
        print(*ans)


import sys
from collections import deque

input=sys.stdin.readline
#sys.setrecursionlimit(2*10**5)

for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    b=list(map(int,input().split()))
    data=[[] for i in range(n)]
    for i in range(n):
        data[a[i]-1].append(i)
        data[b[i]-1].append(i)
    for i in range(n):
        if len(data[i])!=2:
            print(-1)
            break
    else:
        edge=[[] for i in range(n)]
        for i in range(n):
            u,v=data[i][0],data[i][1]
            edge[u].append((v,i))
            edge[v].append((u,i))

        seen=[False]*n
        temp=[]
        res=0
        def dfs(v,cond):
            nonlocal temp,res
            res.append(v)
            if cond==1:
                up,down=a[v],b[v]
            else:
                up,down=b[v],a[v]

            for nv,val in edge[v]:
                if not seen[nv]:
                    seen[nv]=True
                    if a[nv]==up or b[nv]==down:
                        temp.append(nv)
                        dfs(nv,-1)
                    else:
                        dfs(nv,1)

        def bfs(i):
            nonlocal temp,res
            deq=deque([(i,1)])
            while deq:
                v,cond=deq.popleft()
                res.append(v)
                if cond==1:
                    up,down=a[v],b[v]
                else:
                    up,down=b[v],a[v]

                for nv,val in edge[v]:
                    if not seen[nv]:
                        seen[nv]=True
                        if a[nv]==up or b[nv]==down:
                            temp.append(nv)
                            deq.append((nv,-1))
                        else:
                            deq.append((nv,1))

        ans=[]
        for i in range(0,n):
            if not seen[i]:
                res=[]
                temp=[]
                seen[i]=True
                bfs(i)
                if len(res)-len(temp)>=len(temp):
                    ans+=temp
                else:
                    temp=set(temp)
                    for v in res:
                        if v not in temp:
                            ans.append(v)
        if ans:
            ans=[ans[i]+1 for i in range(len(ans))]
        print(len(ans))
        print(*ans)


from sys import stdin, setrecursionlimit
from collections import deque
input = stdin.readline
setrecursionlimit(int(2e5))
def getstr(): return input()[:-1]
def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint1(): return list([int(x) - 1 for x in input().split()])

adj = col = comp = []
cnt0 = cnt1 = 0

def dfs(us, cs, cmp, n):
    nonlocal adj, col, comp, cnt0, cnt1
    stack = [(us, cs)]
    inq = [False] * n
    inq[us] = True
    while len(stack) > 0:
        u, c = stack.pop()
        # print(u, c)
        inq[u] = False
        col[u] = c
        if col[u] == 0: cnt0 += 1
        else: cnt1 += 1
        comp[u] = cmp
        for v, ch in adj[u]:
            if col[v] == -1 and not inq[v]:
                inq[v] = True
                stack.append((v, c ^ ch))
    # print(col, comp)

def solve():
    nonlocal adj, col, comp, cnt0, cnt1
    n = getint()
    a = []
    pos = [[] for _ in range(n)]
    adj = [[] for _ in range(n)]
    for i in [0, 1]:
        a.append(getint1())
        for j, x in enumerate(a[i]):
            pos[x].append(j)
    for i, c in enumerate(pos):
        if len(c) != 2:
            print("-1")
            return
        if c[0] == c[1]: 
            continue
        r1 = int(a[0][c[0]] != i)
        r2 = int(a[0][c[1]] != i)
        adj[c[0]].append((c[1], int(r1 == r2)))
        adj[c[1]].append((c[0], int(r1 == r2)))
    # print(adj)
    col = [-1] * n
    comp = [-1] * n
    colcnt = []
    ans = cnt = 0
    # cnt = 0
    for i in range(n):
        if col[i] == -1:
            cnt0, cnt1 = 0, 0
            dfs(i, 0, cnt, n)
            cnt += 1
            colcnt.append((cnt0, cnt1))
            ans += min(cnt0, cnt1)
    # print(colcnt)

    print(ans)
    alist = []
    for i in range(n):
        chz = int(colcnt[comp[i]][0] < colcnt[comp[i]][1])
        if col[i] ^ chz:
            alist.append(i + 1)
    # print(len(alist))
    print(*alist)

def __starting_point():
    # solve()
    # for t in range(getint()):
    #     print("Case #{}: ".format(t + 1), end="")
    #     solve()
    for _ in range(getint()):
        solve()

__starting_point()

from sys import stdin, setrecursionlimit
from collections import deque
input = stdin.readline
def getstr(): return input()[:-1]
def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint1(): return list([int(x) - 1 for x in input().split()])

adj = col = comp = []
cnt0 = cnt1 = 0

def dfs(us, cs, cmp, n):
    nonlocal adj, col, comp, cnt0, cnt1
    stack = [(us, cs)]
    inq = [False] * n
    inq[us] = True
    while len(stack) > 0:
        u, c = stack.pop()
        # print(u, c)
        inq[u] = False
        col[u] = c
        if col[u] == 0: cnt0 += 1
        else: cnt1 += 1
        comp[u] = cmp
        for v, ch in adj[u]:
            if col[v] == -1 and not inq[v]:
                inq[v] = True
                stack.append((v, c ^ ch))
    # print(col, comp)

def solve():
    nonlocal adj, col, comp, cnt0, cnt1
    n = getint()
    a = []
    pos = [[] for _ in range(n)]
    adj = [[] for _ in range(n)]
    for i in [0, 1]:
        a.append(getint1())
        for j, x in enumerate(a[i]):
            pos[x].append(j)
    for i, c in enumerate(pos):
        if len(c) != 2:
            print("-1")
            return
        if c[0] == c[1]: 
            continue
        r1 = int(a[0][c[0]] != i)
        r2 = int(a[0][c[1]] != i)
        adj[c[0]].append((c[1], int(r1 == r2)))
        adj[c[1]].append((c[0], int(r1 == r2)))
    # print(adj)
    col = [-1] * n
    comp = [-1] * n
    colcnt = []
    ans = cnt = 0
    # cnt = 0
    for i in range(n):
        if col[i] == -1:
            cnt0, cnt1 = 0, 0
            dfs(i, 0, cnt, n)
            cnt += 1
            colcnt.append((cnt0, cnt1))
            ans += min(cnt0, cnt1)
    # print(colcnt)

    print(ans)
    alist = []
    for i in range(n):
        chz = int(colcnt[comp[i]][0] < colcnt[comp[i]][1])
        if col[i] ^ chz:
            alist.append(i + 1)
    # print(len(alist))
    print(*alist)

def __starting_point():
    # solve()
    # for t in range(getint()):
    #     print("Case #{}: ".format(t + 1), end="")
    #     solve()
    for _ in range(getint()):
        solve()

__starting_point()

import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7


for t in range(int(data())):
    n=int(data())
    a1=mdata()
    a2=mdata()
    d=dd(int)
    g=[[] for i in range(n+1)]
    for i in range(n):
        d[a1[i]] += 1
        d[a2[i]] += 1
        if a1[i]==a2[i]:
            continue
        g[a1[i]].append((a2[i],i+1,0))
        g[a2[i]].append((a1[i],i+1,1))
    if max(d.values())>2:
        out(-1)
        continue
    vis=[0]*(n+1)
    vis1=[0]*(n+1)
    ans=[]
    for i in range(1,n+1):
        if vis[i]==0 and g[i]:
            s=[[],[]]
            vis[i]=1
            s[g[i][0][2]].append(g[i][0][1])
            s[1-g[i][1][2]].append(g[i][1][1])
            vis[g[i][0][0]] = -1
            vis[g[i][1][0]] = 1
            vis1[g[i][0][1]] = 1
            vis1[g[i][1][1]] = 1
            q=[]
            q.append(g[i][0][0])
            q.append(g[i][1][0])
            while q:
                a=q.pop()
                if vis[a]==1:
                    for nei in g[a]:
                        if vis1[nei[1]]==0:
                            s[1-nei[2]].append(nei[1])
                            vis[nei[0]] = -1
                            vis1[nei[1]] = 1
                            q.append(nei[0])
                else:
                    for nei in g[a]:
                        if vis1[nei[1]]==0:
                            s[1-nei[2]].append(nei[1])
                            vis[nei[0]] = 1
                            vis1[nei[1]] = 1
                            q.append(nei[0])
            if len(s[0])<len(s[1]):
                ans+=s[0]
            else:
                ans+=s[1]
    out(len(ans))
    outl(ans)






import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7


for t in range(int(data())):
    n=int(data())
    a1=mdata()
    a2=mdata()
    d=dd(int)
    g=[[] for i in range(n+1)]
    for i in range(n):
        d[a1[i]] += 1
        d[a2[i]] += 1
        if a1[i]==a2[i]:
            continue
        g[a1[i]].append((a2[i],i+1,0))
        g[a2[i]].append((a1[i],i+1,1))
    if max(d.values())>2:
        out(-1)
        continue
    vis=[0]*(n+1)
    vis1=[0]*(n+1)
    ans=[]
    for i in range(1,n+1):
        if vis[i]==0 and g[i]:
            s=[[],[]]
            vis[i]=1
            a,b=g[i][0],g[i][1]
            s[a[2]].append(a[1])
            s[1-b[2]].append(b[1])
            vis[a[0]] = -1
            vis[b[0]] = 1
            vis1[a[1]] = 1
            vis1[b[1]] = 1
            q=[]
            q.append(g[i][0][0])
            q.append(g[i][1][0])
            while q:
                a=q.pop()
                for nei in g[a]:
                    if vis1[nei[1]]==0:
                        s[1-nei[2]].append(nei[1])
                        vis[nei[0]] = -1*vis[a]
                        vis1[nei[1]] = 1
                        q.append(nei[0])
            if len(s[0])<len(s[1]):
                ans+=s[0]
            else:
                ans+=s[1]
    out(len(ans))
    outl(ans)






import sys
# range = xrange
# input = raw_input
inp = [int(x) for x in sys.stdin.read().split()]
ii = 0
out = []
def solve(n, A):
    same = [-1]*(2 * n);pos = [-1] * n
    for i in range(2 * n):
        a = A[i]
        if pos[a] == -1:
        	pos[a] = i
        elif pos[a] == -2:
        	return None
        else:
        	p = pos[a]
        	pos[a] = -2
        	same[p] = i
        	same[i] = p    
    ans = []
    found = [0] * (2 * n)
    for root in range(2 * n):
        if found[root]:
        	continue        
        count0 = []
        count1 = []
        node = root
        while not found[node]:
            found[node] = 1
            found[same[node]] = 1            
            if node & 1:
            	count0.append(node >> 1)
            else:
            	count1.append(node >> 1)            
            node = same[node ^ 1]
        if len(count0) < len(count1):
        	ans += count0
        else:
        	ans += count1
    return ans
t = inp[ii]
ii += 1
for _ in range(t):
    n = inp[ii]
    ii += 1
    A = [x - 1 for x in inp[ii: ii + n]]
    ii += n
    B = [x - 1 for x in inp[ii: ii + n]]
    ii += n    
    A = [A[i >> 1] if i & 1 == 0 else B[i >> 1] for i in range(2 * n)]
    ans = solve(n, A)
    if ans is None:
    	out.append('-1')
    else:
    	out.append(str(len(ans)))
    	out.append(' '.join(str(x + 1) for x in ans))
print('\n'.join(out))