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 static java.lang.Math.*;
import static java.util.Arrays.fill;

public class Main {
    static void run() throws IOException {
        file("", "");
        int t = nextInt();
        while (t-- > 0)
            solution();
        end();
    }

    static void solution() throws IOException {
        int n = nextInt();
        int k = nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = nextInt();
        List<mem> l = new ArrayList<>();
        TreeMap<Integer, Integer> tm = new TreeMap<>();
        for (int i = 0; i < n / 2; i++) {
            l.add(create_mem(min(arr[i], arr[n - i - 1]) + 1, 0));
            l.add(create_mem(arr[i] + arr[n - i - 1], 1));
            l.add(create_mem(max(arr[i], arr[n - i - 1]) + k, 2));
            tm.put(arr[i] + arr[n - i - 1], tm.getOrDefault(arr[i] + arr[n - i - 1], 0) + 1);
        }
        Collections.sort(l, new Comparator<mem>() {
            @Override
            public int compare(mem o1, mem o2) {
                if (o1.val != o2.val)
                    return Integer.compare(o1.val, o2.val);
                return Integer.compare(o1.type, o2.type);
            }
        });
        int cur = 0;
        int min = n;
        for (int i = 0; i < l.size(); i++) {
            if (l.get(i).type == 0) {
                cur++;
                min = min(min, cur + (n / 2 - cur) * 2);
            } else if (l.get(i).type == 1) {
                min = min(min, cur - tm.get(l.get(i).val) + (n / 2 - cur) * 2);
            } else {
                cur--;
            }

        }

        out.println(min);

    }


    static mem create_mem(int val, int type) {
        mem y = new mem();
        y.val = val;
        y.type = type;
        return y;
    }

    static class mem {
        int val, type;
    }

    static void Z_function() throws IOException {
        char[] s = nextToken().toCharArray();
        int[] z = new int[s.length];
        for (int i = 1, l = 0, r = 0; i < s.length; i++) {
            if (i <= r)
                z[i] = min(r - i + 1, z[i - l]);
            while (z[i] + i < s.length && s[z[i] + i] == s[z[i]])
                ++z[i];
            if (i + z[i] - 1 > r) {
                l = i;
                r = i + z[i] - 1;
            }
        }
        for (int i = 0; i < z.length; i++) {
            out.print(z[i] + " ");
        }
    }

    static long pow(long a, long b) {
        long h = 1;
        while (b > 0) {
            if (b % 2 != 0) {
                h *= a;
                b--;
            }
            b /= 2;
            a *= a;
        }
        return h;
    }

    static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static void end() {
        out.flush();
        out.close();
    }

    static BufferedReader br;
    static PrintWriter out;

    static void file(String input, String output) {
        if (input.equals("")) {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            try {
                br = new BufferedReader(new FileReader(input));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            try {
                out = new PrintWriter(output);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    static StringTokenizer in = new StringTokenizer("");

    public static String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null) return null;
            in = new StringTokenizer(s);
        }
        return in.nextToken();
    }


    public static int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }


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

    }

}