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 r656p7 {
    private static PrintWriter pw = new PrintWriter(System.out);
    private static InputReader sc = new InputReader();

    static class Pair<T1, T2>{
        T1 first;
        T2 second;
        Pair(T1 first, T2 second){
            this.first = first;
            this.second = second;
        }
    }

    static class InputReader{
        private static BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        private static StringTokenizer tk;

        private void next()throws IOException{
            if(tk == null || !tk.hasMoreTokens())   
                tk = new StringTokenizer(r.readLine());
        }

        private int nextInt()throws IOException{
            next();
            return Integer.parseInt(tk.nextToken());
        }
    }

    private static boolean vis[];
    private static ArrayList<Integer> ans;
    private static ArrayList<ArrayList<Pair<Integer, Integer>>> graph, loc;
    private static int n;

    private static void bfs(int node){
        Queue<Pair<Integer, Integer>> q = new LinkedList<>();

        HashSet<Integer> set0 = new HashSet<>(), set1 = new HashSet<>();
        q.add(new Pair<Integer, Integer>(node, 0));
        vis[node] = true;

        while(!q.isEmpty()){
            Pair<Integer, Integer> el = q.poll();
            int nd = el.first, type = el.second;

            if(type == 0)   set0.add(nd);
            else    set1.add(nd);

            for(Pair<Integer, Integer> nxt : graph.get(nd)){
                if(!vis[nxt.first]){
                    vis[nxt.first] = true;
                    int nxtType = type;

                    if(nxt.second == -1)    nxtType = 1 - nxtType;
                    q.add(new Pair<Integer, Integer>(nxt.first, nxtType));  
                }
            }
        }

        HashSet<Integer> w = set0;
        if(set0.size() > set1.size())
            w = set1;
        
        for(int k : w)
            ans.add(k);
    }

    private static boolean genGraph(){
        for(int i=0; i<n; i++){
            if(loc.get(i).size() != 2)  return false;
            ArrayList<Pair<Integer, Integer>> temp = loc.get(i);

            int nd1 = temp.get(0).first, nd2 = temp.get(1).first, sum = temp.get(0).second + temp.get(1).second;

            int type = (sum == 1) ? 1 : -1;
           
            graph.get(nd1).add(new Pair<Integer, Integer>(nd2, type));
            graph.get(nd2).add(new Pair<Integer, Integer>(nd1, type));
        }

        return true;
    }

    public static void main(String args[])throws IOException{       
        ans = new ArrayList<>();
        graph = new ArrayList<>();
        loc = new ArrayList<>();
        vis = new boolean[2*(int)1e5 + 10];

        int t = sc.nextInt();
        while(t-->0)    solve();

        pw.flush();
        pw.close();
    }

    private static void solve()throws IOException{
        graph.clear();
        loc.clear();
        ans.clear();

        n = sc.nextInt();

        for(int i=0; i<n; i++){
            graph.add(new ArrayList<>());
            
            loc.add(new ArrayList<>());
            vis[i] = false;
        }

        for(int k=0; k<2; k++){
            for(int i=0; i<n; i++){
                int input = sc.nextInt()-1;
                loc.get(input).add(new Pair<Integer, Integer>(i, k));
            }
        }

        if(!genGraph()){
            pw.println(-1);
            return;
        }

        for(int i=0; i<n; i++)
            if(!vis[i]) bfs(i);
        
        pw.println(ans.size());
        for(int k : ans)
            pw.print(+(k+1)+" ");
        pw.println();
    }
}