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 JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Main {

    private static BufferedReader br;
    private static StreamTokenizer st;
    private static PrintWriter pw;

    static final int INF = 1000000007;
    static final int MOD = 998244353;

    static int C[];

    static int lowbit(int x) {
        return x & -x;
    }

    static void add(int x, int val, int n) {
        while (x <= n) {
            C[x] += val;
            x += lowbit(x);
        }
    }

    static int getSum(int x) {
        int res = 0;
        while (x > 0) {
            res += C[x];
            x -= lowbit(x);
        }
        return res;
    }

    static int cntBit(int x) {
        int res = 0;
        while (x > 0) {
            res += x % 2;
            x >>= 1;
        }
        return res;
    }

    private static class Tree {
        int cntL;
        int left;
        int right;
        static int target = 0;

        Tree(int left, int right) {
            this.left = left;
            this.right = right;
        }

        static void updateUp(Map<Integer, Tree> lineTree, int k) {
            lineTree.get(k).cntL = lineTree.get(k << 1).cntL + lineTree.get(k << 1 | 1).cntL;
        }

        static void build(int l, int r, Map<Integer, Tree> lineTree, int a[], int k) {
            lineTree.put(k, new Tree(l, r));
            if (l == r) {
                if (a[l] <= target) {
                    lineTree.get(k).cntL = 1;
                }
                return;
            }
            int mid = l + (r - l) / 2;
            build(l, mid, lineTree, a, k << 1);
            build(mid + 1, r, lineTree, a, k << 1 | 1);
            updateUp(lineTree, k);
        }

        static int query(int L, int R, int l, int r, Map<Integer, Tree> lineTree, int k) {
            if (L <= l && r <= R) {
                return lineTree.get(k).cntL;
            }
            if (r < L || l > R) {
                return 0;
            }
            int mid = l + (r - l) / 2;
            int sum = 0;
            sum += query(L, R, l, mid, lineTree, k << 1);
            sum += query(L, R, mid + 1, r, lineTree, k << 1 | 1);
            return sum;
        }

        static void update(Map<Integer, Tree> lineTree, int k, int val) {
            lineTree.get(k).cntL = val;
            while (k > 0) {
                k >>= 1;
                updateUp(lineTree, k >> 1);
            }
        }
    }

    static List<Integer> edges[];
    static int dst[];
    static int child[];
    static int fa[];

    static int dfs(int f, int p, int d) {
        List<Integer> es = edges[f];
        for (int i = 0; i < es.size(); i++) {
            int t = es.get(i);
            if (t == p) {
                continue;
            }
            child[f] += dfs(t, f, d + 1);
        }
        dst[f] = d;
        fa[f] = p;
        return child[f] + 1;
    }

    static int up(long a[], long val) {
        int low = 0;
        int high = a.length;
        while (low < high) {
            int mid = (low + high) / 2;
            if (a[mid] < val) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low;
    }

    static int down(long a[], long val) {
        int low = 0;
        int high = a.length;
        while (low < high) {
            int mid = (low + high) / 2;
            if (a[mid] <= val) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low - 1;
    }

    private static void solve() throws IOException {
        int t = nextInt();
        int dp[] = new int[31];
        for (int cs = 1; cs <= t; cs++) {
            int n = nextInt();
            int k = nextInt();
            int a[] = new int[n];
            C = new int[2 * k + 1];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            for (int i = 0; i < n / 2; i++) {
                int min = Math.min(a[i], a[n - i - 1]);
                int max = Math.max(a[i], a[n - i - 1]);
                int sum = a[i] + a[n - i - 1];
                add(1, 2, k << 1);
                add(min + 1, -1, k << 1);
                add(sum, -1, k << 1);
                add(sum + 1, 1, k << 1);
                add(max + k + 1, 1, k << 1);
            }
            int res = n;
            for (int i = 2; i <= k << 1; i++) {
                res = Math.min(res, getSum(i));
            }
            pw.print(res);


//            pw.format("Case #%d: %f", cs, 1.0 - del);
            if (cs < t) {
                pw.println();
            }
        }
    }

    static void getDiv(Map<Integer, Integer> map, int n) {
        int sqrt = (int) Math.sqrt(n);
        for (int i = sqrt; i >= 2; i--) {
            if (n % i == 0) {
                getDiv(map, i);
                getDiv(map, n / i);
                return;
            }
        }
        map.put(n, map.getOrDefault(n, 0) + 1);
    }

    public static boolean[] generatePrime(int n) {
        boolean p[] = new boolean[n + 1];
        p[2] = true;

        for (int i = 3; i <= n; i += 2) {
            p[i] = true;
        }

        for (int i = 3; i <= Math.sqrt(n); i += 2) {
            if (!p[i]) {
                continue;
            }
            for (int j = i * i; j <= n; j += i << 1) {
                p[j] = false;
            }
        }
        return p;
    }

    static boolean isPrime(long n) { //determines if n is a prime number
        int p[] = {2, 3, 5, 233, 331};
        int pn = p.length;
        long s = 0, t = n - 1;//n - 1 = 2^s * t
        while ((t & 1) == 0) {
            t >>= 1;
            ++s;
        }
        for (int i = 0; i < pn; ++i) {
            if (n == p[i]) {
                return true;
            }
            long pt = pow(p[i], t, n);
            for (int j = 0; j < s; ++j) {
                long cur = llMod(pt, pt, n);
                if (cur == 1 && pt != 1 && pt != n - 1) {
                    return false;
                }
                pt = cur;
            }
            if (pt != 1) {
                return false;
            }
        }
        return true;
    }

    static long llMod(long a, long b, long mod) {
        return (a * b - (long) ((double) a / mod * b + 0.5) * mod + mod) % mod;
//        long r = 0;
//        a %= mod;
//        b %= mod;
//        while (b > 0) {
//            if ((b & 1) == 1) {
//                r = (r + a) % mod;
//            }
//            b >>= 1;
//            a = (a << 1) % mod;
//        }
//        return r;
    }

    static int pow(long a, long n) {
        long ans = 1;
        while (n > 0) {
            if ((n & 1) == 1) {
                ans = (ans * a) % MOD;
            }
            a = (a * a) % MOD;
            n >>= 1;
        }
        return (int) ans;
    }

    static int pow(long a, long n, long mod) {
        long ans = 1;
        while (n > 0) {
            if ((n & 1) == 1) {
                ans = llMod(ans, a, mod);
            }
            a = llMod(a, a, mod);
            n >>= 1;
        }
        return (int) ans;
    }

    private static long[][] initC(int n) {
        long c[][] = new long[n][n];

        for (int i = 0; i < n; i++) {
            c[i][0] = 1;
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= i; j++) {
                c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
            }
        }
        return c;
    }

    /**
     * ps: n >= m, choose m from n;
     */
    private static int c(long n, long m) {
        if (m > n) {
            n ^= m;
            m ^= n;
            n ^= m;
        }
        m = Math.min(m, n - m);

        long top = 1;
        long bot = 1;
        for (long i = n - m + 1; i <= n; i++) {
            top = (top * i) % MOD;
        }
        for (int i = 1; i <= m; i++) {
            bot = (bot * i) % MOD;
        }

        return (int) ((top * pow(bot, MOD - 2)) % MOD);
    }

    static int gcd(int a, int b) {
        if (a < b) {
            a ^= b;
            b ^= a;
            a ^= b;
        }
        while (b != 0) {
            int tmp = a % b;
            a = b;
            b = tmp;
        }
        return a;
    }

    static boolean even(long n) {
        return (n & 1) == 0;
    }

    public static void main(String args[]) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        st.ordinaryChar('\'');
        st.ordinaryChar('\"');
        st.ordinaryChar('/');

        long t = System.currentTimeMillis();
        solve();
        pw.flush();
    }

    private static long[] anLong(int n) throws IOException {
        long a[] = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    private static String next(int len) throws IOException {
        char ch[] = new char[len];
        int cur = 0;
        char c;
        while ((c = (char) br.read()) == '\n' || c == '\r' || c == ' ' || c == '\t') ;
        do {
            ch[cur++] = c;
        } while (!((c = (char) br.read()) == '\n' || c == '\r' || c == ' ' || c == '\t'));
        return String.valueOf(ch, 0, cur);
    }

    private static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    private static long nextLong() throws IOException {
        st.nextToken();
        return (long) st.nval;
//        return Long.parseLong(nextLine());
    }

    private static double nextDouble() throws IOException {
        st.nextToken();
        return st.nval;
    }

    private static String[] nextSS(String reg) throws IOException {
        return br.readLine().split(reg);
    }

    private static String nextLine() throws IOException {
        return br.readLine();
    }
}