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 java.io.*;
import java.util.*;
public class Main{
	static int n;
	static ArrayList<Integer> adjList [];
	static int [] dfs_num, dfs_low, visited, component, rootOfComponent, firstRow;
	static int dfsNumberCounter, numSCC;
	static Stack <Integer> S;
	static int UNVISITED = 0;
	static int V;//V = 2 * number of vertices 
				 //even numbers -> vertices , odd numbers -> negation of vertices 
	public static void tarjanSCC(int u)
	{
	        dfs_low[u] = dfs_num[u] = ++dfsNumberCounter;
	        S.push(u);
	        visited[u] = 1;
	        for (int v : adjList[u])
	        {
	                if (dfs_num[v] == UNVISITED)
	                        tarjanSCC(v);
	                if (visited[v] == 1)
	                        dfs_low[u] = Math.min(dfs_low[u], dfs_low[v]);
	        }
 
	        if (dfs_low[u] == dfs_num[u])
	        {
	                while (true)
	                {
	                        int v = S.pop();
	                        visited[v] = UNVISITED;
	                        component[v] = numSCC;
	                        if(((v&1)==0 && (v>>1)<n) || ((v&1)==1 && (v>>1)>=n)) {
	                        	firstRow[numSCC]++;
	                        }
	                        if (u == v) break;
	                }
	                rootOfComponent[numSCC] = u;
	                numSCC++;
	        }
	}
 
	public static void tarjanSCC ()
	{
	        dfs_low = new int[V];
	        dfs_num = new int[V];
	        visited = new int[V];
	        component = new int[V];
	        rootOfComponent = new int[V];
	        firstRow=new int[V];
	        S = new Stack<>();
	        dfsNumberCounter = 0;
	        numSCC = 0;
	        for (int i = 0; i < V; ++i)
	                if (dfs_num[i] == UNVISITED)
	                        tarjanSCC(i);
	}
 
	static int NOT (int x) {
		return x ^ 1;
	}
	 
	// acceptable values: (0, 1), (1, 0), (1, 1)
	static void OR(int a, int b) {
        adjList[NOT(a)].add(b);
        adjList[NOT(b)].add(a);
	}
	 
	// acceptable values: (0, 1), (1, 0)
	static void or_but_not_both(int a, int b) {
	    // CNF: (a v b) & (!a v !b)  ==> E.g. can't be true for (1, 1) / (0, 0)
        OR(a, b);
        OR(NOT(a), NOT(b));
	}
	static void bothOrNone(int a, int b) {
        // CNF: (!a v b) & (a v !b)  ==> E.g. can't be true for (0, 1) / (1, 0)
        OR(NOT(a), b);
        OR(a, NOT(b));
	}
	 
	// x -> y = (not x) or y
	 
 
	static boolean is_solvable() {
	        for (int i = 0; i < V; i += 2)
	                if (component[i] == component[NOT(i)])
	                        return false;
	        return true;
	}
 
	static int[] assign_values() {
			//choosing which node will be in the first row
	        int comp_result [] = new int[numSCC];
	        Arrays.fill(comp_result, -1);
	        for (int i = 0; i < numSCC; i++) {
	                if (comp_result[i] == -1) {
	                	int not_ithcomp = component[NOT(rootOfComponent[i])];
	                	if(firstRow[i]>=firstRow[not_ithcomp]) {
	                		comp_result[i] = 1;
                        	comp_result[not_ithcomp] = 0;
	                	}
	                	else {
	                		comp_result[i] = 0;
                        	comp_result[not_ithcomp] = 1;
	                	}
	                }
	        }
 
	        int[]res=new int[V];
	        for (int i = 0; i < V; i++) res[i] = comp_result[component[i]];
	        return res;
	}
	static int node(int[]pos) {
		int x=pos[0]*n+pos[1];
		return x<<1;
	}
	static void main() throws Exception{
		n=sc.nextInt();
		int[][]in=new int[2][n];
		LinkedList<int[]>[]pos=new LinkedList[n];
		for(int i=0;i<n;i++)pos[i]=new LinkedList<int[]>();
		for(int i=0;i<2;i++) {
			for(int j=0;j<n;j++) {
				in[i][j]=sc.nextInt()-1;
				pos[in[i][j]].add(new int[] {i,j});
			}
		}
		for(int i=0;i<n;i++) {
			if(pos[i].size()!=2) {
				pw.println(-1);
				return;
			}
		}
		V=n<<2;
		adjList=new ArrayList[V];
		for(int i=0;i<V;i++) {
			adjList[i]=new ArrayList<Integer>();
		}
		for(int i=0;i<n;i++) {
			int[]firstPos=pos[i].getFirst(),secondPos=pos[i].getLast();
			or_but_not_both(node(firstPos), node(secondPos));
		}
		for(int i=0;i<n;i++) {
			or_but_not_both(node(new int[] {0,i}), node(new int[] {1,i}));
		}
		
		tarjanSCC();
		if(!is_solvable()) {
			pw.println(-1);
			return;
		}
		int[]assigned=assign_values();
		int cnt=0;
		StringBuilder ans=new StringBuilder();
		for(int i=0;i<n;i++) {
			if(assigned[i<<1]==0) {
				cnt++;
				ans.append((i+1)+" ");
			}
		}
		pw.println(cnt);
		pw.println(ans);
	}
	public static void main(String[] args) throws Exception{
		sc=new MScanner(System.in);
		pw = new PrintWriter(System.out);
		int tc=1;
		tc=sc.nextInt();
		while(tc-->0)
			main();
		pw.flush();
	}
	static PrintWriter pw;
	static MScanner  sc;
	static class MScanner {
		StringTokenizer st;
		BufferedReader br;
		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int[] intArr(int n) throws IOException {
	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public long[] longArr(int n) throws IOException {
	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public int[] intSortedArr(int n) throws IOException {
	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        shuffle(in);
	        Arrays.sort(in);
	        return in;
		}
		public long[] longSortedArr(int n) throws IOException {
	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        shuffle(in);
	        Arrays.sort(in);
	        return in;
		}
		public Integer[] IntegerArr(int n) throws IOException {
	        Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public Long[] LongArr(int n) throws IOException {
	        Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
	static void shuffle(int[]in) {
		for(int i=0;i<in.length;i++) {
			int idx=(int)(Math.random()*in.length);
			int tmp=in[i];
			in[i]=in[idx];
			in[idx]=tmp;
		}
	}
	static void shuffle(long[]in) {
		for(int i=0;i<in.length;i++) {
			int idx=(int)(Math.random()*in.length);
			long tmp=in[i];
			in[i]=in[idx];
			in[idx]=tmp;
		}
	}
}