description: You have a permutation: an array a = [a_1, a_2, …, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.
  
  You need to sort the permutation in increasing order.
  
  In one step, you can choose any prefix of the permutation with an odd length and reverse it. Formally, if a = [a_1, a_2, …, a_n], you can choose any odd integer p between 1 and n, inclusive, and set a to [a_p, a_{p-1}, …, a_1, a_{p+1}, a_{p+2}, …, a_n].
  
  Find a way to sort a using no more than 5n/2 reversals of the above kind, or determine that such a way doesn't exist. The number of reversals doesn't have to be minimized.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
  
  The first line of each test case contains a single integer n (3 ≤ n ≤ 2021; n is odd) — the length of the permutation.
  
  The second line contains n distinct integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the permutation itself. 
  
  It is guaranteed that the sum of n over all test cases does not exceed 2021.
  
  Output
  
  For each test case, if it's impossible to sort the given permutation in at most 5n/2 reversals, print a single integer -1.
  
  Otherwise, print an integer m (0 ≤ m ≤ 5n/2), denoting the number of reversals in your sequence of steps, followed by m integers p_i (1 ≤ p_i ≤ n; p_i is odd), denoting the lengths of the prefixes of a to be reversed, in chronological order.
  
  Note that m doesn't have to be minimized. If there are multiple answers, print any.
  
  Example
  
  Input
  
  
  3
  3
  1 2 3
  5
  3 4 5 2 1
  3
  2 1 3
  
  
  Output
  
  
  4
  3 3 3 3
  2
  3 5
  -1
  
  Note
  
  In the first test case, the permutation is already sorted. Any even number of reversals of the length 3 prefix doesn't change that fact.
  
  In the second test case, after reversing the prefix of length 3 the permutation will change to [5, 4, 3, 2, 1], and then after reversing the prefix of length 5 the permutation will change to [1, 2, 3, 4, 5].
  
  In the third test case, it's impossible to sort the permutation.
solution: from sys import stdin, stdout
  import heapq
  from collections import defaultdict
  import math
  import bisect
  import io, os
  
  # for interactive problem
  # n = int(stdin.readline())
  # print(x, flush=True)
  
  #input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
  
  def ncr(n, r, p):
      # initialize numerator
      # and denominator
      num = den = 1
      for i in range(r):
          num = (num * (n - i)) % p
          den = (den * (i + 1)) % p
      return (num * pow(den,
              p - 2, p)) % p
  
  
  def main():
      #n = int(input())
      t = int(stdin.readline())
      for _ in range(t):
          n = int(stdin.readline())
          arr = list(map(int, stdin.readline().split()))
          is_ok = True
          for i in range(n):
              if arr[i] % 2 == i % 2:
                  is_ok = False
                  break
          if not is_ok:
              stdout.write("-1\n")
              continue
          ans = []
          for i in range(0,n-2,2):
              x = n - i
              y = n - i - 1
              pos_x = pos_y = 0
              for j in range(n-i):
                  if arr[j] == x:
                      pos_x = j
                  if arr[j] == y:
                      pos_y = j
                  if pos_x and pos_y:
                      break
              if abs(pos_x - pos_y) != 1:
                  if pos_x != 0:
                      ans.append(pos_x+1)
                      for k in range(pos_x // 2):
                          arr[k], arr[pos_x-k] = arr[pos_x-k], arr[k]
                      if pos_y < pos_x:
                          pos_y = pos_x - pos_y
                      pos_x = 0
                  ans.append(pos_y)
                  for k in range(pos_y // 2):
                      arr[k], arr[pos_y-1-k] = arr[pos_y-1-k], arr[k]
                  pos_x = pos_y - 1
              if pos_y > pos_x and pos_x != 0:
                  ans.append(pos_y+2)
                  for k in range((pos_y + 1) // 2):
                      arr[k], arr[pos_y + 1 - k] = arr[pos_y + 1 - k], arr[k]
                  pos_y = 1
                  pos_x = 2
              if pos_x > pos_y and pos_x != n - i - 1:
                  ans.append(pos_x+1)
                  for k in range(pos_x // 2):
                      arr[k], arr[pos_x - k] = arr[pos_x - k], arr[k]
                  pos_y = pos_x - pos_y
                  pos_x = 0
              if pos_x == 0:
                  ans.append(n-i)
                  for k in range((n - i) // 2):
                      arr[k], arr[n - i - k - 1] = arr[n - i - k - 1], arr[k]
          if len(ans):
              stdout.write(str(len(ans))+"\n")
              stdout.write(" ".join([str(x) for x in ans]) + "\n")
          else:
              stdout.write("2\n3 3\n")
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  main()
  