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

Solution:


def main1():
    T = int(input())
    results = []
    for case in range(1, T + 1):
        n, k = [int(i) for i in input().split()]
        a = [int(i) for i in input().split()]

        sums = set()
        sums_dict = {}
        best_changes = 1e9
        su = k + 1
        changes = 0
        for i in range(n // 2):
            a1 = a[i]
            a2 = a[~i]
            add = a1 + a2
            if (add != su):
                changes += 1
            sums.add(add)
            if (add not in sums_dict.keys()):
                sums_dict[add] = 0
            sums_dict[add] += 1
        best_changes = min(best_changes, changes)
        for su in sums:
            changes = 0
            if ((n // 2) - sums_dict[su] > best_changes):
                continue
            for i in range(n // 2):
                a1 = a[i]
                a2 = a[~i]
                add = a1 + a2
                if (add != su):
                    changes += 1
                    if (add > su):
                        changes += int(max(a1, a2) - (add - su) < 1)
                    elif (add < su):
                        changes += int(min(a1, a2) + (su - add) > k)
                if (changes >= best_changes):
                    break
            best_changes = min(best_changes, changes)
        results.append(best_changes)

    for result in results:
        print (result)

def main2():
    T = int(input())
    results = []
    for case in range(1, T + 1):
        n, k = [int(i) for i in input().split()]
        a = [int(i) for i in input().split()]
        dp = [0 for i in range(2 * k + 1 + 1)]
        dp[0] = n
        for i in range(n // 2):
            a1 = a[i]
            a2 = a[~i]
            add = a1 + a2
            small = min(a1, a2)
            big = max(a1, a2)
            upper_bound = add + (k - small)
            lower_bound = add - (big - 1)
            dp[lower_bound] -= 1
            dp[add] -= 1
            dp[add + 1] += 1
            dp[upper_bound + 1] += 1
        changes = []
        csum = 0
        for su in dp:
            csum += su
            changes.append(csum)
        results.append(min(changes))
    for result in results:
        print (result)

main2()