Problem: You are given a positive integer n, it is guaranteed that n is even (i.e. divisible by 2).

You want to construct the array a of length n such that: 

  * The first n/2 elements of a are even (divisible by 2); 
  * the second n/2 elements of a are odd (not divisible by 2); 
  * all elements of a are distinct and positive; 
  * the sum of the first half equals to the sum of the second half (∑_{i=1}^{n/2} a_i = ∑_{i=n/2 + 1}^{n} a_i). 



If there are multiple answers, you can print any. It is not guaranteed that the answer exists.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.

The only line of the test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. It is guaranteed that that n is even (i.e. divisible by 2).

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).

Output

For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) satisfying conditions from the problem statement on the second line.

Example

Input


5
2
4
6
8
10


Output


NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
  x = 0;
  char o, f = 1;
  while (o = getchar(), o < 48)
    if (o == 45) f = -f;
  do x = (x << 3) + (x << 1) + (o ^ 48);
  while (o = getchar(), o > 47);
  x *= f;
}
const long long inf = ~0u >> 2;
const long long INF = ~0ull >> 2;
const long long maxn = 2e5 + 10;
long long a[maxn], n, k;
struct tnode {
  long long sum, lazy;
  long long l, r;
};
struct Segment_Tree {
  tnode t[8 * maxn];
  void pushdown(long long root) {
    if (t[root].lazy != 0) {
      t[root].sum += t[root].lazy * (t[root].r - t[root].l + 1);
      if (t[root].l != t[root].r) {
        long long ch = root << 1;
        t[ch].lazy += t[root].lazy;
        t[ch + 1].lazy += t[root].lazy;
      }
      t[root].lazy = 0;
    }
  }
  void update(long long root) {
    long long ch = root << 1;
    pushdown(ch);
    pushdown(ch + 1);
    t[root].sum = t[ch].sum + t[ch + 1].sum;
  }
  void build(long long l, long long r, long long root = 1) {
    t[root].l = l;
    t[root].r = r;
    if (l != r) {
      long long mid = (l + r) >> 1;
      long long ch = root << 1;
      build(l, mid, ch);
      build(mid + 1, r, ch + 1);
      update(root);
    } else {
      t[root].sum = 0;
    }
  }
  void change(long long l, long long r, long long delta, long long root = 1) {
    if (l == t[root].l && r == t[root].r) {
      t[root].lazy += delta;
      pushdown(root);
      return;
    }
    long long mid = (t[root].l + t[root].r) >> 1;
    long long ch = root << 1;
    if (r <= mid)
      change(l, r, delta, ch);
    else if (l > mid)
      change(l, r, delta, ch + 1);
    else {
      change(l, mid, delta, ch);
      change(mid + 1, r, delta, ch + 1);
    }
    update(root);
  }
  long long sum(long long l, long long r, long long root = 1) {
    pushdown(root);
    if (t[root].l == l && t[root].r == r) {
      return t[root].sum;
    }
    long long mid = (t[root].l + t[root].r) >> 1;
    long long ch = root << 1;
    if (r <= mid)
      return sum(l, r, ch);
    else if (l > mid)
      return sum(l, r, ch + 1);
    else
      return sum(l, mid, ch) + sum(mid + 1, r, ch + 1);
  }
} tree;
void solve() {
  rd(n), rd(k);
  tree.build(1, 2 * k, 1);
  for (long long i = 1; i <= n; i++) rd(a[i]);
  for (long long i = 1; i <= n / 2; i++) {
    long long q = a[i] + a[n - i + 1];
    long long pp = min(a[i], a[n - i + 1]) + 1;
    if (pp == 2 && q - 1 >= pp) {
      tree.change(pp, q - 1, 1);
    } else if (pp > 2 && q - 1 >= pp) {
      tree.change(2, pp - 1, 2);
      tree.change(pp, q - 1, 1);
    }
    if (q == 2 * k) continue;
    long long p = min(2 * k, max(a[i], a[n - i + 1]) + k);
    if (p == 2 * k && q + 1 <= 2 * k) {
      tree.change(q + 1, 2 * k, 1);
    } else if (p >= q + 1 && p + 1 <= 2 * k) {
      tree.change(q + 1, p, 1);
      tree.change(p + 1, 2 * k, 2);
    }
  }
  long long ans = INF;
  for (long long i = 2; i <= 2 * k; i++) ans = min(ans, tree.sum(i, i));
  printf("%lld\n", ans);
  return;
}
int main() {
  long long T;
  rd(T);
  while (T--) solve();
  return 0;
}