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
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))
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))