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.nio.CharBuffer;
import java.util.*;

public class P1343D {

    public static void main(String[] args) {
        SimpleScanner scanner = new SimpleScanner(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        int caseNum = scanner.nextInt();
        while (caseNum-- > 0) {
            int n = scanner.nextInt();
            int k = scanner.nextInt();
            int[] x = new int[n];
            for (int i = 0; i < n; ++i)
                x[i] = scanner.nextInt();
            TreeMap<Integer, Integer> sumCntMap = new TreeMap<>();
            ArrayList<Integer> min = new ArrayList<>(n);
            ArrayList<Integer> max = new ArrayList<>(n);
            for (int i = 0; i < n / 2; ++i) {
                int sum = x[i] + x[n - i - 1];
                sumCntMap.compute(sum, (t, v) -> v == null ? 1 : v + 1);
                min.add(Math.min(x[i], x[n - i - 1]));
                max.add(Math.max(x[i], x[n - i - 1]));
            }
            min.sort(Comparator.naturalOrder());
            max.sort(Comparator.naturalOrder());
            int ans = n / 2;
            int lt = 0;
            int nlt = 0;
            for (Map.Entry<Integer, Integer> entry : sumCntMap.entrySet()) {
                int sum = entry.getKey();
                int cnt = entry.getValue();
                if (sum <= k) {
                    while (lt < n / 2 && min.get(lt) < sum)
                        ++lt;
                    ans = Math.min(ans, n - cnt * 2 - (lt - cnt));
                } else {
                    while (nlt < n / 2 && max.get(nlt) < sum - k)
                        ++nlt;
                    ans = Math.min(ans, n - cnt * 2 - (n / 2 - cnt - nlt));
                }
            }
            writer.println(ans);
        }

        writer.close();
    }

    private static class SimpleScanner {

        private static final int BUFFER_SIZE = 10240;

        private Readable in;
        private CharBuffer buffer;
        private boolean eof;

        private SimpleScanner(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
            buffer = CharBuffer.allocate(BUFFER_SIZE);
            buffer.limit(0);
            eof = false;
        }


        private char read() {
            if (!buffer.hasRemaining()) {
                buffer.clear();
                int n;
                try {
                    n = in.read(buffer);
                } catch (IOException e) {
                    n = -1;
                }
                if (n <= 0) {
                    eof = true;
                    return '\0';
                }
                buffer.flip();
            }
            return buffer.get();
        }

        private void checkEof() {
            if (eof)
                throw new NoSuchElementException();
        }

        private char nextChar() {
            checkEof();
            char b = read();
            checkEof();
            return b;
        }

        private String next() {
            char b;
            do {
                b = read();
                checkEof();
            } while (Character.isWhitespace(b));
            StringBuilder sb = new StringBuilder();
            do {
                sb.append(b);
                b = read();
            } while (!eof && !Character.isWhitespace(b));
            return sb.toString();
        }

        private int nextInt() {
            return Integer.parseInt(next());
        }

        private long nextLong() {
            return Long.parseLong(next());
        }

        private double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}