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.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

/**
 * Codeforces Problem 1343D
 */
public class Solution {

	public static void main(String args[]) {
		try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
				 PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));) {
			int t = Integer.parseInt(in.readLine());
			for (int i = 0; i < t; i++) {
				String solution = solveNext(in);
				out.println(solution);
			}
			out.flush();
		} catch (IOException ex) {
			throw new RuntimeException(ex);
		}
		System.exit(0);
	}

	public static String solveNext(BufferedReader in) throws IOException {
		String[] line = in.readLine().split(" ");
		int n = Integer.parseInt(line[0]);
		int k = Integer.parseInt(line[1]);
		int[] nums = new int[n];
		line = in.readLine().split(" ");
		for (int i = 0; i < n; i++) {
			nums[i] = Integer.parseInt(line[i]);
		}
		return new Solution(n, k, nums).solve();
	}

	final int n;
	final int k;
	final int[] nums;

	public Solution(int n, int k, int[] nums) {
		this.n = n;
		this.k = k;
		this.nums = nums;
	}

	private static class NumSum {

		final int index;
		final int sum;
		final int minSum;
		final int maxSum;

		public NumSum(int i, int a, int b, int k) {
			this.index = i;
			this.sum = a + b;
			int minNum = Math.min(a, b);
			int maxNum = Math.max(a, b);
			this.minSum = minNum + 1;
			this.maxSum = maxNum + k;
		}
	}

	private int getLessThan(int[] nums, int a) {
		int left = -1;
		int right = nums.length;
		while (right - left > 1) {
			int middle = (right + left) / 2;
			if (nums[middle] < a) {
				left = middle;
			} else {
				right = middle;
			}
		}
		return right;
	}

	private int getGreaterThan(int[] nums, int a) {
		int left = -1;
		int right = nums.length;
		while (right - left > 1) {
			int middle = (right + left) / 2;
			if (nums[middle] > a) {
				right = middle;
			} else {
				left = middle;
			}
		}
		return nums.length - right;
	}

	public String solve() {
		int half = this.n / 2;
		int[] minSums = new int[half];
		int[] maxSums = new int[half];
		Map<Integer, Integer> sumCounts = new HashMap<>();
		for (int i = 0; i < half; i++) {
			int a = this.nums[i];
			int b = this.nums[this.n - 1 - i];
			int sum = a + b;
			Integer count = sumCounts.get(sum);
			if (count == null) {
				count = 0;
			}
			count++;
			sumCounts.put(sum, count);

			int minNum = Math.min(a, b);
			int maxNum = Math.max(a, b);
			minSums[i] = minNum + 1;
			maxSums[i] = maxNum + this.k;
		}

		Random random = ThreadLocalRandom.current();
		int index, temp;
		for (int i = half - 1; i > 0; i--) {
			index = random.nextInt(i + 1);
			temp = minSums[index];
			minSums[index] = minSums[i];
			minSums[i] = temp;

			index = random.nextInt(i + 1);
			temp = maxSums[index];
			maxSums[index] = maxSums[i];
			maxSums[i] = temp;
		}

		Arrays.sort(minSums);
		Arrays.sort(maxSums);
		int minChange = this.n;
		int minSum = minSums[0];
		int maxSum = maxSums[half - 1];
		for (int i = minSum; i <= maxSum; i++) {
			int count = half;
			Integer sumCount = sumCounts.get(i);
			if (sumCount != null) {
				count -= sumCount;
			}
			count += this.getLessThan(maxSums, i);
			count += this.getGreaterThan(minSums, i);
			minChange = Math.min(minChange, count);
		}

		return Integer.toString(minChange);

	}

}