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.*;
    import java.math.*;
    import java.lang.*;

    import static java.lang.Math.*;

    public class Main implements Runnable
    {
        static class InputReader
        {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

            public InputReader(InputStream stream)
            {
                this.stream = stream;
            }

            public int read()
            {
                if (numChars==-1)
                    throw new InputMismatchException();

                if (curChar >= numChars)
                {
                    curChar = 0;
                    try
                    {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e)
                    {
                        throw new InputMismatchException();
                    }

                    if(numChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }

            public String nextLine()
            {
                String str = "";
                try
                {
                    str = br.readLine();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt()
            {
                int c = read();

                while(isSpaceChar(c))
                    c = read();

                int sgn = 1;

                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }

                int res = 0;
                do
                {
                    if(c<'0'||c>'9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));

                return res * sgn;
            }

            public long nextLong()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                long res = 0;

                do
                {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                    return res * sgn;
            }

            public double nextDouble()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.')
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.')
                {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c))
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }

            public String readString()
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do
                {
                    res.appendCodePoint(c);
                    c = read();
                }
                while (!isSpaceChar(c));

                return res.toString();
            }

            public boolean isSpaceChar(int c)
            {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            public String next()
            {
                return readString();
            }

            public interface SpaceCharFilter
            {
                public boolean isSpaceChar(int ch);
            }
        }


        public static void main(String args[]) throws Exception
        {
            new Thread(null, new Main(),"Main",1<<26).start();
        }
        //User-defined functions goes here...
        class pair{
            int x, y;
            pair(int x, int y){
                this.x = x;
                this.y = y;
            }
        }

        class sort_res implements Comparator<pair>{
            public int compare(pair a, pair b){
                if(a.x == b.x)
                    return a.y-b.y;
                return a.x - b.x;
            }
        }

        void swap(int[] a, int pos1, int pos2){
            int temp = a[pos1];
            a[pos1] = a[pos2];
            a[pos2] = temp;
        }

        ArrayList<pair>[] graph;
        int cnt[], ww[];

        void dfs(int node, int p){
            if(graph[node].size()==1 && p != -1)
                cnt[p]=1;
            
            for (pair temp: graph[node]) {
                if(temp.y == p)
                    continue;

                dfs(temp.x, temp.y);

                if(p!=-1)   
                    cnt[p] += cnt[temp.y];
            }
        }

        long getdiff(int i){
            return (cnt[i] * 1l * ww[i] - cnt[i] * 1l * (ww[i]/2));
        }

        class TreeComparator implements Comparator<treepair>{
            public int compare(treepair a, treepair b){
                if(b.x - a.x < 0)
                    return 1;
                else if(b.x - a.x > 0)
                    return -1;
                else
                    return (int)(b.y-a.y);
            }
        }

        class treepair{
            long x;
            int y;

            treepair(long x, int y){
                this.x = x;
                this.y = y;
            }
        }

    
        ArrayList<Integer>[] rg;
        TreeSet<Integer> val;
        int[][] dp;


        int calc(int l, int r){
            if(dp[l][r] != -1)
                return dp[l][r];

            dp[l][r] = 0;

            if(l > r)
                return dp[l][r];

            int flag = 0;
            for (int rr : rg[l]) {
                if(rr == r){
                    flag = 1;
                    break;
                }
            }

            dp[l][r] = Math.max(dp[l][r], flag + (l + 1 > r? 0 : calc(l+1, r)));

            for (int nr : rg[l] ) {
                if(nr >= r)
                    continue;
                dp[l][r] = Math.max(dp[l][r], flag + calc(l, nr) + (nr + 1 > r ? 0 : calc(nr + 1, r)));
            }
            return dp[l][r];
        }

        class freq_comp implements Comparator<Integer>{
            public int compare(Integer a, Integer b){
                return colsc[(int)b] - colsc[(int)a];
            }
        }
        int colsc[];

        boolean powerof2(int n){
            return ((n > 2) && ((n & (n-1)) == 0));
        }

        public void run()
        {
            InputReader sc= new InputReader(System.in);
            PrintWriter w= new PrintWriter(System.out);

            //Your code goes here...
            int test = sc.nextInt();
            for (int q0=0; q0<test; q0++) {
                int n = sc.nextInt();
                int k = sc.nextInt();

                int arr[] = new int[n];
                for (int i=0; i<n; i++) {
                    arr[i] = sc.nextInt();   
                }

                int cnt[] = new int[2*k+1];
                for (int i=0; i<n/2; i++) {
                     cnt[arr[i] + arr[n-i-1]]++;

                 } 

                int pref[] = new int[2*k+2];
                for (int i=0; i<n/2; i++) {
                    int l1 = arr[i] + 1, l2 = arr[i] + k;
                    int r1 = arr[n-i-1]+1, r2=arr[n-i-1]+k;
                    pref[min(l1, r1)]++;
                    pref[max(l2, r2)+1]--;
                }

                for (int i=1; i<=2*k+1; i++) {
                    pref[i] += pref[i-1];
                }

                int ans = Integer.MAX_VALUE;
                for (int i=2; i<2*k+1; i++) {
                    ans = Math.min(ans, (pref[i]-cnt[i]) + (n/2 - pref[i])*2);
                }

                w.println(ans);
            }

            w.close();
        }
    }