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
#include <bits/stdc++.h>
const long long INF = 1000000001;
using namespace std;
vector<pair<long long, long long> > a, num;
vector<long long> ans;
vector<bool> s;
pair<bool, long long> k;
long long next1(long long x, long long y) {
  if (a[num[y].first].first != x && a[num[y].first].first != y) {
    k = {true, num[y].first};
    return a[num[y].first].first;
  }
  if (a[num[y].first].second != x && a[num[y].first].second != y) {
    k = {false, num[y].first};
    return a[num[y].first].second;
  }
  if (a[num[y].second].first != x && a[num[y].second].first != y) {
    k = {true, num[y].second};
    return a[num[y].second].first;
  }
  k = {false, num[y].second};
  return a[num[y].second].second;
}
void func(long long x) {
  s[x] = false;
  if (num[x].first == num[x].second) {
    return;
  }
  long long now = next1(-1, x), last = x;
  s[now] = false;
  long long quan = k.first, q1 = 1;
  if (next1(x, now) == x || next1(x, now) == now) {
    if ((a[num[x].first].first == x && a[num[x].second].first == x) ||
        (a[num[x].first].second == x && a[num[x].second].second == x)) {
      ans.push_back(num[x].first);
    }
    return;
  }
  while (now != x) {
    s[now] = false;
    swap(last, now);
    now = next1(now, last);
    quan += k.first, q1++;
  }
  now = next1(-1, x), last = x;
  if ((k.first && quan <= q1 / 2) || (!k.first && quan > q1 / 2)) {
    ans.push_back(k.second);
  }
  while (now != x) {
    swap(last, now);
    now = next1(now, last);
    if ((k.first && quan <= q1 / 2) || (!k.first && quan > q1 / 2)) {
      ans.push_back(k.second);
    }
  }
}
signed main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  long long t1;
  cin >> t1;
  for (long long q11 = 0; q11 < t1; q11++) {
    long long n;
    cin >> n;
    a.assign(n, {-1, -1}), num.assign(n, {-1, -1}), s.assign(n, true), ans = {};
    for (long long q = 0; q < n; q++) {
      cin >> a[q].first;
      if (num[--a[q].first].first == -1) {
        num[a[q].first].first = q;
      } else {
        num[a[q].first].second = q;
      }
    }
    for (long long q = 0; q < n; q++) {
      cin >> a[q].second;
      if (num[--a[q].second].first == -1) {
        num[a[q].second].first = q;
      } else {
        num[a[q].second].second = q;
      }
    }
    bool flag = true;
    for (long long q = 0; q < n; q++) {
      flag &= (num[q].second != -1);
    }
    if (!flag) {
      cout << -1 << '\n';
    } else {
      for (long long q = 0; q < n; q++) {
        if (s[q]) {
          func(q);
        }
      }
      cout << ans.size() << '\n';
      for (long long q : ans) {
        cout << q + 1 << ' ';
      }
      cout << '\n';
    }
  }
  return 0;
}
