You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.

Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:

  * after all replacements, all a_i are positive integers not greater than k; 
  * for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements. 



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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.

It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).

Output

For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.

Example

Input


4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4


Output


0
1
4
2
import heapq
import sys
input=sys.stdin.readline

t=int(input())
for _ in range(t):
    n=int(input())
    arr=list(map(int,input().split()))
    turned=0
    q=[]
    for i in range(n):
        heapq.heappush(q,arr[i])
        for j in range(i+1,n):
            if arr[i]>arr[j]:
                turned+=1
    if turned==0:
        print(0)
        print('')
    else:
        if n==3:
            if n==len(set(arr)):
                if turned%2==1:
                    print(-1)
                else:
                    cnt=1
                    ans=[1]
                    arr[0],arr[1],arr[2]=arr[2],arr[0],arr[1]
                    if arr[0]<=arr[1]<=arr[2]:
                        print(cnt)
                        print(*ans)
                    else:
                        cnt+=1
                        ans.append(1)
                        print(cnt)
                        print(*ans)
            else:
                cnt=1
                ans=[1]
                arr[0],arr[1],arr[2]=arr[2],arr[0],arr[1]
                if arr[0]<=arr[1]<=arr[2]:
                    print(cnt)
                    print(*ans)
                else:
                    cnt+=1
                    ans.append(1)
                    print(cnt)
                    print(*ans)
            continue
        if n==len(set(arr)):
            if turned%2==1:
                print(-1)
            else:
                cnt=0
                pos=0
                ans=[]
                while pos<n:
                    tmp=heapq.heappop(q)
                    if arr[pos]==tmp:
                        pos+=1
                        continue
                    else:
                        tpos=pos+arr[pos:].index(tmp)
                        while tpos-pos>=2:
                            cnt+=1
                            tpos-=2
                            ans.append(tpos+1)
                            tmp=0
                            if arr[tpos]>arr[tpos+1]:
                                tmp+=1
                            if arr[tpos]>arr[tpos+2]:
                                tmp+=1
                            if arr[tpos+1]>arr[tpos+2]:
                                tmp+=1
                            arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+2],arr[tpos],arr[tpos+1]
                            if arr[tpos]>arr[tpos+1]:
                                tmp-=1
                            if arr[tpos]>arr[tpos+2]:
                                tmp-=1
                            if arr[tpos+1]>arr[tpos+2]:
                                tmp-=1
                            turned-=tmp
                        if tpos-pos==1:
                            cnt+=2
                            tpos-=1
                            ans.append(tpos+1)
                            ans.append(tpos+1)
                            tmp=0
                            if arr[tpos]>arr[tpos+1]:
                                tmp+=1
                            if arr[tpos]>arr[tpos+2]:
                                tmp+=1
                            if arr[tpos+1]>arr[tpos+2]:
                                tmp+=1
                            arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+1],arr[tpos+2],arr[tpos]
                            if arr[tpos]>arr[tpos+1]:
                                tmp-=1
                            if arr[tpos]>arr[tpos+2]:
                                tmp-=1
                            if arr[tpos+1]>arr[tpos+2]:
                                tmp-=1
                            turned-=tmp
                        pos+=1
                print(cnt)
                print(*ans)
        else:
            cnt=0
            pos=0
            ans=[]
            while pos<n-2:
                tmp=heapq.heappop(q)
                if arr[pos]==tmp:
                    pos+=1
                    continue
                else:
                    tpos=pos+arr[pos:].index(tmp)
                    while tpos-pos>=2:
                        cnt+=1
                        tpos-=2
                        ans.append(tpos+1)
                        tmp=0
                        if arr[tpos]>arr[tpos+1]:
                            tmp+=1
                        if arr[tpos]>arr[tpos+2]:
                            tmp+=1
                        if arr[tpos+1]>arr[tpos+2]:
                            tmp+=1
                        arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+2],arr[tpos],arr[tpos+1]
                        if arr[tpos]>arr[tpos+1]:
                            tmp-=1
                        if arr[tpos]>arr[tpos+2]:
                            tmp-=1
                        if arr[tpos+1]>arr[tpos+2]:
                            tmp-=1
                        turned-=tmp
                    if tpos-pos==1:
                        cnt+=2
                        tpos-=1
                        ans.append(tpos+1)
                        ans.append(tpos+1)
                        tmp=0
                        if arr[tpos]>arr[tpos+1]:
                            tmp+=1
                        if arr[tpos]>arr[tpos+2]:
                            tmp+=1
                        if arr[tpos+1]>arr[tpos+2]:
                            tmp+=1
                        arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+1],arr[tpos+2],arr[tpos]
                        if arr[tpos]>arr[tpos+1]:
                            tmp-=1
                        if arr[tpos]>arr[tpos+2]:
                            tmp-=1
                        if arr[tpos+1]>arr[tpos+2]:
                            tmp-=1
                        turned-=tmp
                    pos+=1
            if turned==0:
                print(cnt)
                print(*ans)
            else:
                ttpos=-1
                for i in range(n-2,-1,-1):
                    if arr[i]==arr[i+1]:
                        ttpos=i
                        break
                if ttpos==-1:
                    cnt+=1
                    ans.append(n-2)
                    arr[n-3],arr[n-2],arr[n-1]=arr[n-1],arr[n-3],arr[n-2]
                    if arr[n-3]<=arr[n-2]<=arr[n-1]:
                        print(cnt)
                        print(*ans)
                    else:
                        cnt+=1
                        ans.append(n-3)
                        print(cnt)
                        print(*ans)
                else:
                    cnt+=2
                    ans.append(ttpos+1)
                    ans.append(ttpos+1)
                    arr[ttpos],arr[ttpos+1],arr[ttpos+2]=arr[ttpos+1],arr[ttpos+2],arr[ttpos]
                    turned+=1
                    q=[]
                    for i in range(n):
                        heapq.heappush(q,arr[i])
                    pos=0
                    while pos<n-2:
                        tmp=heapq.heappop(q)
                        if arr[pos]==tmp:
                            pos+=1
                            continue
                        else:
                            tpos=pos+arr[pos:].index(tmp)
                            while tpos-pos>=2:
                                cnt+=1
                                tpos-=2
                                ans.append(tpos+1)
                                arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+2],arr[tpos],arr[tpos+1]
                            if tpos-pos==1:
                                cnt+=2
                                tpos-=1
                                ans.append(tpos+1)
                                ans.append(tpos+1)
                                arr[tpos],arr[tpos+1],arr[tpos+2]=arr[tpos+1],arr[tpos+2],arr[tpos]
                            pos+=1
                    print(cnt)
                    print(*ans)