A permutation of length n is an array p=[p_1,p_2,...,p_n], which contains every integer from 1 to n (inclusive) and, moreover, each number appears exactly once. For example, p=[3,1,4,2,5] is a permutation of length 5.

For a given number n (n ≥ 2), find a permutation p in which absolute difference (that is, the absolute value of difference) of any two neighboring (adjacent) elements is between 2 and 4, inclusive. Formally, find such permutation p that 2 ≤ |p_i - p_{i+1}| ≤ 4 for each i (1 ≤ i < n).

Print any such permutation for the given integer n or determine that it does not exist.

Input

The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then t test cases follow.

Each test case is described by a single line containing an integer n (2 ≤ n ≤ 1000).

Output

Print t lines. Print a permutation that meets the given requirements. If there are several such permutations, then print any of them. If no such permutation exists, print -1.

Example

Input


6
10
2
4
6
7
13


Output


9 6 10 8 4 7 3 1 5 2 
-1
3 1 4 2 
5 3 6 2 4 1 
5 1 3 6 2 4 7 
13 9 7 11 8 4 1 3 5 2 6 10 12 
import java.util.*;

public class SpecialPermutation {
    public static void main(String[] args) {
        /**
         * brute force
         * find all permutations and then check if one of them is
         * the correct answer
         * this leads to a total O(n*n!)
         *
         * So how can we avoid finding all permutations?
         *
         *  9 6 10 8 4 7 3 1 5 2
         *  2 5 1 3 7 4 8 10 6 9
         *
         *
         *  backtracking + checking if a feasible solution is possible with the
         *  given set of numbers to backtrack efficiently
         *
         *
         *  so given a set of numbers we should know if such a sequence can be
         *  generated
         *
         *  initially we are given n -> [1,n]
         *  we know this will obviously be able to give a solution
         *
         *  we need to check for any other set of numbers which lie between
         *  1 to n (not all included)
         *
         *  eg: 1 3 5, check if such a solution is possible
         *  to check we need to see what is the starting number after which this sequence
         *  will fit in
         *
         *  improved eg: 2 (1, 3, 5)
         *
         *  or just backtract simply with a condition that next number should be
         *  available and in the range of +- 2 to 4
         *
         *  1 [3,4,5,6]  1 3 []
         *
          */


        Scanner sc= new Scanner(System.in);

        int t = sc.nextInt();
        while (t-->0){
            int n = sc.nextInt();
            Set<Integer> available = new HashSet();
            Stack<Integer> result = new Stack<>();
            for(int i=1;i<=n;i++){
                available.add(i);
            }

            if(findPermute(available, result, n)){
                StringBuilder rs = new StringBuilder();
                for(Integer x: result){
                    rs.append(x + " ");
                }
                System.out.println(rs.toString().trim());
            } else {
                System.out.println("-1");
            }

        }
    }


    static boolean findPermute(Set<Integer> available, Stack<Integer> result, int n) {
        if(result.size()==n) return true;
        if(available.size()==0) {
            System.out.println(result);
            return false;
        }

        int[] arr = {-4, -3, -2, 2, 3, 4};

        for(int x: new ArrayList<Integer>(available)){
//            System.out.println(x);

            if(result.size()>0 && (Math.abs(x - result.peek())<2
                    || Math.abs(x - result.peek())>4)){
                continue;
            }

            available.remove(x);
            result.push(x);

            for(int i: arr){
                if(available.contains(x+i)){
                    available.remove(x+i);
                    result.push(x+i);

                    if(findPermute(available, result, n)) return true;
                    available.add(x+i);
                    result.pop();
                }
            }

            if(available.size()==0 && result.size()==n) return true;
            available.add(x);
            result.pop();
        }

//        System.out.println(result);
        return false;
    }
}
























