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>
using namespace std;
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
  pr(first);
  pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void prContain(const T& x) {
  pr("{");
  bool fst = 1;
  for (auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
  pr("}");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
  prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
  prContain(x);
}
template <class T>
void pr(const set<T>& x) {
  prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prContain(x);
}
void ps() { pr("\n"); }
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
  pr(first, " ");
  ps(rest...);
}
template <typename T>
int remin(T& a, const T& b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
int remax(T& a, const T& b) {
  if (b > a) {
    a = b;
    return true;
  }
  return false;
}
const int MX = 2E5 + 5;
int n;
vector<pair<int, int> > G[MX];
int color[MX];
set<int> groups[2];
void dfs(int u, int col = 0) {
  if (color[u] != -1) {
    assert(color[u] == col);
    return;
  }
  color[u] = col;
  groups[col].insert(u);
  for (auto [v, c] : G[u]) {
    dfs(v, c ^ col);
  }
}
void solve() {
  scanf("%d", &n);
  vector<vector<int> > c(n + 1), r(n + 1);
  for (int k = 0; k < n; ++k) {
    color[k] = -1;
    G[k].clear();
  }
  for (int i = 0; i < n; ++i) {
    int k;
    scanf("%d", &k);
    c[k].push_back(i);
    r[k].push_back(0);
  }
  for (int i = 0; i < n; ++i) {
    int k;
    scanf("%d", &k);
    c[k].push_back(i);
    r[k].push_back(1);
  }
  for (int k = 1; k <= n; ++k) {
    if ((int)c[k].size() != 2) {
      printf("-1\n");
      return;
    }
  }
  for (int k = 1; k <= n; ++k) {
    if (c[k][0] == c[k][1]) continue;
    if (r[k][0] == r[k][1]) {
      G[c[k][0]].emplace_back(c[k][1], 1);
      G[c[k][1]].emplace_back(c[k][0], 1);
    } else {
      G[c[k][0]].emplace_back(c[k][1], 0);
      G[c[k][1]].emplace_back(c[k][0], 0);
    }
  }
  vector<int> ans;
  for (int u = 0; u < n; ++u) {
    if (color[u] != -1) continue;
    groups[0].clear();
    groups[1].clear();
    dfs(u);
    if (groups[0].size() < groups[1].size()) {
      ans.insert(ans.end(), groups[0].begin(), groups[0].end());
    } else {
      ans.insert(ans.end(), groups[1].begin(), groups[1].end());
    }
  }
  printf("%d\n", (int)ans.size());
  for (int x : ans) {
    printf("%d ", x + 1);
  }
  printf("\n");
}
int main(int argc, const char** argv) {
  int TT;
  scanf("%d", &TT);
  for (int tt = 1; tt <= TT; ++tt) {
    solve();
  }
  return 0;
}
