You are given a table a of size 2 × 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 ≤ j ≤ 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 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.

The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 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}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ 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}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ 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 ⋅ 10^5 (∑ n ≤ 2 ⋅ 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, ..., pos_k in the second line (1 ≤ pos_i ≤ 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 io
import os

from collections import Counter, defaultdict, deque


def bfs(source, getNbr):
    q = deque([source])
    dist = {source: 0}
    while q:
        node = q.popleft()
        d = dist[node]
        for nbr in getNbr(node):
            if nbr not in dist:
                q.append(nbr)
                dist[nbr] = d + 1
    return dist


def solve(N, A1, A2):
    A = A1 + A2  # index bottom row with N to 2N - 1

    # Put edge for any two cells that have to be on opposite sides
    graph = [[] for i in range(2 * N)]

    # Put edge between same column
    for i in range(N):
        if A[i] != A[i + N]:  # Skip columns with same values which is handled below
            graph[i].append(i + N)
            graph[i + N].append(i)

    # Put edge between same value
    valToCols = defaultdict(list)
    for i, x in enumerate(A):
        valToCols[x].append(i)
    for x in range(1, N + 1):
        if len(valToCols[x]) != 2:
            return -1
        i, j = valToCols[x]
        graph[i].append(j)
        graph[j].append(i)

    def getNbr(u):
        return graph[u]

    # Two color
    ans = []
    seen = {}
    for source in range(2 * N):
        if source not in seen:
            dist = bfs(source, getNbr)
            for u in dist.keys():
                color = dist[u] % 2
                for v in graph[u]:
                    color2 = dist[v] % 2
                    if color == color2:  # conflict
                        return -1
            # The components can flip, choose smaller
            cols1 = [u for u in dist.keys() if u < N and dist[u] % 2 == 0]
            cols2 = [u for u in dist.keys() if u < N and dist[u] % 2 == 1]
            if len(cols1) < len(cols2):
                ans.extend(cols1)
            else:
                ans.extend(cols2)
            seen.update(dist)

    return str(len(ans)) + "\n" + " ".join(str(c + 1) for c in ans)


if False:
    # print(solve(5, [1, 1, 2, 3, 4], [2, 3, 4, 5, 5]))

    import random

    random.seed(0)

    from itertools import combinations, product

    for t in range(10000):
        N = 5

        for perm1 in product(range(1, N + 1), repeat=N):
            for perm2 in product(range(1, N + 1), repeat=N):
                best = float("inf")
                for mask in range(1 << N):
                    p1 = list(perm1)
                    p2 = list(perm2)
                    for i in range(N):
                        if mask & (1 << i):
                            p1[i], p2[i] = p2[i], p1[i]
                    if sorted(p1) == sorted(p2) == sorted(range(1, N + 1)):
                        best = min(best, bin(mask).count("1"))
                if best == float("inf"):
                    best = -1
                ans = int(str(solve(N, perm1, perm2)).split("\n")[0])

                if ans != best:
                    print(perm1, perm2, best, ans)
    exit()
if __name__ == "__main__":
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

    T = int(input())
    for t in range(T):
        (N,) = [int(x) for x in input().split()]
        A1 = [int(x) for x in input().split()]
        A2 = [int(x) for x in input().split()]
        ans = solve(N, A1, A2)
        print(ans)
