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;
const int maxn = 2e5 + 100;
struct node {
  int flag, a, b;
  long long sum;
} t[maxn * 8];
int a[maxn], cnt[maxn * 2], js[maxn * 2];
void pushdown(int x, int l, int r) {
  if (t[x].flag) {
    int num = t[x].flag;
    t[2 * x].sum += num * l;
    t[2 * x + 1].sum += num * r;
    t[2 * x].flag += num;
    t[2 * x + 1].flag += num;
    t[x].flag = 0;
  }
}
int ask(int x, int l, int r, int pos) {
  int mid;
  if (l == r) {
    return t[x].sum;
  }
  mid = (l + r) / 2;
  pushdown(x, mid - l + 1, r - mid);
  if (pos <= mid)
    return ask(2 * x, l, mid, pos);
  else
    return ask(2 * x + 1, mid + 1, r, pos);
}
void add(int x, int l, int r, int ql, int qr, int val) {
  int mid;
  if (ql == l && qr == r) {
    t[x].flag += val;
    t[x].sum += (qr - ql + 1);
    return;
  }
  mid = (l + r) / 2;
  pushdown(x, mid - l + 1, r - mid);
  if (qr <= mid) {
    add(2 * x, l, mid, ql, qr, val);
  } else {
    if (ql > mid)
      add(2 * x + 1, mid + 1, r, ql, qr, val);
    else {
      add(2 * x, l, mid, ql, mid, val);
      add(2 * x + 1, mid + 1, r, mid + 1, qr, val);
    }
  }
  t[x].sum = t[2 * x].sum + t[2 * x + 1].sum;
}
void build(int x, int l, int r) {
  int mid;
  t[x].flag = 0;
  t[x].sum = 0;
  if (l == r) {
    return;
  }
  mid = (l + r) / 2;
  build(2 * x, l, mid);
  build(2 * x + 1, mid + 1, r);
}
int top;
node s[maxn];
int cmp(node a, node b) { return a.sum < b.sum; }
int main() {
  node e;
  int T, n, flag, ans, k, up;
  scanf("%d", &T);
  while (T--) {
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= 2 * k; i++) {
      cnt[i] = 0;
      js[i] = 0;
    }
    build(1, 1, k * 2);
    for (int i = 1; i <= n; i++) {
      scanf("%d", &a[i]);
    }
    if (n == 2) {
      printf("0\n");
      continue;
    }
    top = 0;
    if (n % 2)
      up = n / 2 + 1;
    else
      up = n / 2;
    for (int i = 1; i <= up; i++) {
      e.a = a[i];
      e.b = a[n - i + 1];
      if (e.a > e.b) swap(e.a, e.b);
      e.sum = e.a + e.b;
      s[++top] = e;
      js[e.sum]++;
    }
    sort(s + 1, s + top + 1, cmp);
    int last = 0;
    ans = n;
    for (int i = 1; i <= top; i++) {
      e = s[i];
      if (e.sum == last) {
        add(1, 1, 2 * k, e.a + 1, e.b + k, 1);
        continue;
      }
      cnt[e.sum] += n / 2 - js[e.sum] + i - 1 - ask(1, 1, 2 * k, e.sum);
      add(1, 1, 2 * k, e.a + 1, e.b + k, 1);
      last = e.sum;
    }
    for (int i = 1; i <= top / 2; i++) {
      swap(s[i], s[top - i + 1]);
    }
    build(1, 1, k * 2);
    last = 0;
    ans = n;
    for (int i = 1; i <= top; i++) {
      e = s[i];
      if (e.sum == last) {
        add(1, 1, 2 * k, e.a + 1, e.b + k, 1);
        continue;
      }
      cnt[e.sum] += i - 1 - ask(1, 1, 2 * k, e.sum);
      ans = min(ans, cnt[e.sum]);
      add(1, 1, 2 * k, e.a + 1, e.b + k, 1);
      last = e.sum;
    }
    for (int i = 1; i <= 2 * k; i++) {
      if (js[i]) continue;
      ans = min(ans, n - ask(1, 1, 2 * k, i));
    }
    printf("%d\n", ans);
  }
  return 0;
}