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.*;
    import java.math.*;
    import java.lang.*;

    import static java.lang.Math.*;

    public class Main implements Runnable
    {
        static class InputReader
        {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

            public InputReader(InputStream stream)
            {
                this.stream = stream;
            }

            public int read()
            {
                if (numChars==-1)
                    throw new InputMismatchException();

                if (curChar >= numChars)
                {
                    curChar = 0;
                    try
                    {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e)
                    {
                        throw new InputMismatchException();
                    }

                    if(numChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }

            public String nextLine()
            {
                String str = "";
                try
                {
                    str = br.readLine();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt()
            {
                int c = read();

                while(isSpaceChar(c))
                    c = read();

                int sgn = 1;

                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }

                int res = 0;
                do
                {
                    if(c<'0'||c>'9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));

                return res * sgn;
            }

            public long nextLong()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                long res = 0;

                do
                {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                    return res * sgn;
            }

            public double nextDouble()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.')
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.')
                {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c))
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }

            public String readString()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do
                {
                    res.appendCodePoint(c);
                    c = read();
                }
                while (!isSpaceChar(c));

                return res.toString();
            }

            public boolean isSpaceChar(int c)
            {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            public String next()
            {
                return readString();
            }

            public interface SpaceCharFilter
            {
                public boolean isSpaceChar(int ch);
            }
        }


        public static void main(String args[]) throws Exception
        {
            new Thread(null, new Main(),"Main",1<<26).start();
        }
        //User-defined functions goes here...
        class pair{
            int x, y;
            pair(int x, int y){
                this.x = x;
                this.y = y;
            }
        }

        void dfs(int node, int c, int cmp){
            col[node] = c;
            if(c == 0)
                cnt0++;
            else
                cnt1++;

            comp[node] = cmp;
            for (pair temp : graph[node]) {
                if(col[temp.x] == -1)
                    dfs(temp.x, c ^ temp.y, cmp);
            }
        }

        int cnt0, cnt1;
        ArrayList<pair>[] graph;
        int col[], comp[];
       
        public void run()
        {
            InputReader sc= new InputReader(System.in);
            PrintWriter w= new PrintWriter(System.out);

            //Your code goes here...
            int test = sc.nextInt();
            for (int q0=0; q0<test; q0++) {
                int n = sc.nextInt();
                int a[][] = new int[2][n];
                ArrayList<Integer>[] pos = new ArrayList[n];
                for (int i=0; i<n; i++) {
                    pos[i] = new ArrayList<>(2);
                }
                for (int i=0; i<n; i++) {
                    a[0][i] = sc.nextInt()-1;
                    pos[a[0][i]].add(i);
                    
                }
                for (int i=0; i<n; i++) {
                    a[1][i] = sc.nextInt()-1;
                    pos[a[1][i]].add(i);
                }

                boolean bad = false;

                graph = new ArrayList[n];
                for (int i=0; i<n; i++) {
                    graph[i] = new ArrayList<pair>();
                }

                for (int i=0; i<n; i++) {
                    if(pos[i].size() != 2){
                        bad = true;
                        break;
                    }
                    int c1 = pos[i].get(0);
                    int c2 = pos[i].get(1);

                    if(c2 == c1)
                        continue;
                    int r1 = a[0][c1] == i? 1 : 0;
                    int r2 = a[1][c2] == i? 1 : 0;

                    graph[c1].add(new pair(c2, r1==r2? 0: 1));
                    graph[c2].add(new pair(c1, r1==r2? 0: 1));
                }

                int cnt = 0;
                col = new int[n];
                Arrays.fill(col, -1);
                comp = new int[n];
                int ans = 0;

                ArrayList<pair> colcnt = new ArrayList<>(); 

                for (int i=0; i<n; i++) {
                    if(col[i] == -1){
                        cnt0 = cnt1 = 0;
                        dfs(i, 0, cnt);
                        cnt++;
                        colcnt.add(new pair(cnt0, cnt1));
                        ans += Math.min(cnt0, cnt1);
                    }
                }

                for (int i=0; i<n; i++) {
                    for(pair temp : graph[i]){
                        if((col[temp.x] ^ col[i]) != temp.y)
                            bad = true;
                    }
                }

                if(bad){
                    w.println("-1");
                }
                else{
                    w.println(ans);
                    for (int i=0; i<n; i++) {
                        int changeOne = colcnt.get(comp[i]).x < colcnt.get(comp[i]).y ? 1: 0;
                        if((col[i] ^ changeOne) == 1? true: false)
                            w.print((i+1) + " ");
                    }
                    w.println();
                }

            }
            
            w.close();
        }
    }