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 PYTHON):

Solution:
__author__ = 'Devesh Bajpai'

'''
https://codeforces.com/problemset/problem/1343/B

Solution: The question has a few conditions and we shall need to exploit odd-even numbers' properties to handle that.

We know that 2 odd numbers can sum to make an even number. Hence for n sized array, if we put n/2 even and n/2 odd 
numbers, those n/2 odd numbers should for pairs to sum to even so that jointly that can be equal to the sum of even side
which would be even anyways. Therefore, the even half (or odd half) should at least be even as well. In other words, 
the smallest array possible can be of size 4, and all possible array sizes have to be multiples of 4. This can take care
of the "NO" condition.

Now for the actual numbers, we can use the natural numbers from 1 to n-1 to build the even half and one less than odd
half of the numbers. Every even number differs by 1 from its odd neighbors. Hence if we have n = 8

2, 4, 6, 8, 1, 3, 5, x can be the possible solution. Now the question arises what should x be. 
For that lets decompose the numbers.

2, 4, 6, 8, 1, 3, 5, x 

2, 4, 6, 8, 2-1, 4-1, 6-1, x

So if we generalize, 

2, 4,....n, 2-1, 4-1, .... x

So 
The even numbers sum is (2 + 4 + .... n)  
The odd numbers sum is (2-1 + 4-1 + .... x) 
=  (2 + 4 + .... x) - 1* (n/2 - 1)

Since the even and odd numbers sum is required to be same, we can equate the LHS and RHS here:

(2 + 4 + .... n)  = (2 + 4 + .... x) - 1* (n/2 - 1)
n + 1* (n/2 - 1) = x

(3n - 2)/2 = x

So for n = 8, x = 11

Note that this is just a strategy that we can use to find the desired array. I suppose there can be other ways as well. 
  
'''


def solve(n):

    if n % 4 != 0:
        return "NO"

    evenHalf = ""
    for i in xrange(1, n/2 + 1):
        evenHalf += str(2 * i) + " "

    oddHalf = ""
    for i in xrange(1, n/2):
        oddHalf += str((2 * i) - 1) + " "
    oddHalf += str((3*n - 2)/2)

    return "YES" + "\n" + evenHalf + oddHalf


if __name__ == "__main__":
    t = int(raw_input())

    results = list()
    for _ in xrange(0, t):
        n = int(raw_input())
        results.append(solve(n))

    for result in results:
        print result