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 r636p4 {

    private static int n, k;
    private static long res[];
    private static int inp[];
    private static Node root;

    static class Node{

        int begin, end;
        Node left, right;
        int data, lazy;
        
        Node(int b, int e){
            begin = b;
            end = e;
            data = 0;
            lazy = 0;

            if(begin != end){
                left = new Node(begin, (begin+end)/2);
                right = new Node((begin+end)/2+1, end);
            }
        }

        void set(int l, int r, int val){
            if(l<0 || r<0 || l > 2*k || r > 2*k || l>r || l>end || begin>r) return;

            if(l <= begin && end <= r){
                if(begin != end)
                    lazy += val;
                else
                    data += val;
                //pw.println(+begin+" "+end+" "+l+" "+r+" "+val);
                return;
            }

            if(lazy != 0){
                left.set(begin, (begin+end)/2, lazy);
                right.set((begin+end)/2+1, end, lazy);
                lazy = 0;
            }

            left.set(l, r, val);
            right.set(l, r, val);
        }

        void genRes(){
            if(begin != end){
                left.lazy += lazy;
                right.lazy += lazy;
                lazy = 0;
                left.genRes();
                right.genRes();
            }
            else{
                data += lazy;
                res[begin] = data;
            }
        }
    }

    private static void input()throws IOException{
        n = nextInt();
        k = nextInt();
        inp = intArray(n);
        res = new long[2*k+1];
    }

    private static void cal(){
        root = new Node(0, 2*k);
        for(int i=0; i<n/2; i++){
            int min = Math.min(inp[i], inp[n-i-1]), max = Math.max(inp[i], inp[n-i-1]), sum = inp[i]+inp[n-i-1];
            root.set(2, min, 2);
            root.set(min+1, sum-1, 1);
            //root.set(sum, sum, 0);
            root.set(sum+1, max+k, 1);
            root.set(max+k+1, 2*k, 2);
        }

        root.genRes();
        long min = Integer.MAX_VALUE;
        for(int i=2; i<=2*k; i++){
            min = Math.min(min, res[i]);
            //pw.print(+res[i]+" ");
        }
    
        //pw.println("\n"+min);

        pw.println(+min);
    }

    private static void solve()throws IOException{
        input();
        cal();
    }

    private static BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer tk;
    private static PrintWriter pw = new PrintWriter(System.out);

    private static void next()throws IOException{
        if(tk == null || !tk.hasMoreTokens())   
            tk = new StringTokenizer(r.readLine());
    }

    private static int nextInt()throws IOException{
        next();
        return Integer.parseInt(tk.nextToken());
    }

    private static long nextLong()throws IOException{
        next();
        return Long.parseLong(tk.nextToken());
    }

    private static String readString()throws IOException{
        next();
        return tk.nextToken();
    }

    private static double nextDouble()throws IOException{
        next();
        return Double.parseDouble(tk.nextToken());
    }

    private static int[] intArray(int n)throws IOException{
        next();
        int arr[] = new int[n];

        for(int i=0; i<n; i++)
            arr[i] = nextInt();

        return arr;
    }

    private static long[] longArray(int n)throws IOException{
        next();
        long arr[] = new long[n];

        for(int i=0; i<n; i++)
            arr[i] = nextLong();

        return arr;
    }

    public static void main(String args[])throws IOException{

        int t = nextInt();
        while(t-->0)
            solve();

        pw.flush();
        pw.close();
    }
}