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.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;

import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
import static java.util.Arrays.sort;
import static java.util.Arrays.parallelSort;
import static java.util.Arrays.binarySearch;

public class cf {
    static final Scanner sc = new Scanner(System.in);
    static final Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static final int mod = (int) (1e9 + 7);
    static final int modf = 998244353;
    static final Reader r = new Reader();
    static final PrintWriter out = new PrintWriter(System.out);

    public static void main(final String[] args) throws IOException {
        int testcases = r.nextInt();
        // int testcases = 1;

        for (int i = 0; i < testcases; i++) {
            long an = solve();
            out.println(an);
            // out.println(an==0?"NO":"YES");
            // out.print("Case "+i+1+": ");
        }
        out.flush();
        out.close();
        sc.close();
    }

    static int[] level, p;
    static Vector<Integer>[] adj;

    private static long solve() throws IOException {
        int n = r.nextInt();
        int k = r.nextInt();
        int[] a = new int[n];
        int[] f = new int[2 * k + 2];
        int[] f0 = new int[2 * k + 2];
        for (int i = 0; i < a.length; i++) {
            a[i] = r.nextInt();
        }
        int max = 0;
        for (int i = 0; i < a.length / 2; i++) {
            f0[a[i] + a[n - i - 1]]++;
            max = max(a[i], a[n - i - 1]) + k + 1;
            f[max]--;
            f[min(a[i], a[n - i - 1]) + 1]++;

        }
        int asum = 0;
        for (int i = 0; i < f.length; i++) {
            asum += f[i];
            f[i] = asum;
        }
        long ans = n/2;
        for (int i = 2; i < f.length; i++) {
            int temp = n/2-f[i]+f0[i];
            temp = n/2- f[i];
            ans = min(ans, f[i]-f0[i]+temp*2);

        }

        return ans;
    }

    static int get_closest(long value, int[] a) {

        if (value < a[0]) {
            return a[0];
        }
        if (value > a[a.length - 1]) {
            return a[a.length - 1];
        }

        int lo = 0;
        int hi = a.length - 1;

        while (lo <= hi) {
            int mid = (hi + lo) / 2;

            if (value < a[mid]) {
                hi = mid - 1;
            } else if (value > a[mid]) {
                lo = mid + 1;
            } else {
                return a[mid];
            }
        }
        // lo == hi + 1
        return (a[lo] - value) < (value - a[hi]) ? a[lo] : a[hi];
    }

    private static void addEdge(int u, int v) {
        adj[u] = (adj[u] == null) ? new Vector<>() : adj[u];
        adj[v] = (adj[v] == null) ? new Vector<>() : adj[v];
        adj[u].add(v);
        adj[v].add(u);
    }

    private static int dfs(int cur, int prev, int dep, Vector<Integer>[] adj) {
        // if (FAI[cur] == -1)
        // FAI[cur] = ptr;
        level[cur] = dep;
        // euler.add(fact);

        // ptr++;
        int size = 1;
        for (Integer x : adj[cur]) {
            if (x != prev) {
                size += dfs(x, cur, dep + 1, adj);
                // euler.add(fact);
                // ptr++;
            }
        }
        level[cur] = dep - size + 1;
        return size;
    }

    static int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private final DataInputStream din;
        private final byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(final String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            final byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }
}