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.*;
import java.io.*;
 
public class Main {
 
	public static void main(String[] args) throws IOException,InterruptedException{
        Scanner sc = new Scanner(System.in);
	       int t=sc.nextInt();
	       while(t-->0) {
	    	int n=sc.nextInt();
	    	LinkedList<Integer> ll=new LinkedList<>();
	    	if (n<4) {
				pw.println(-1);
			}else if(n==4) {
				pw.println("3 1 4 2");
			}else {
				ll.add(3);
		    	ll.add(1);
		    	ll.add(4);
		    	ll.add(2);
		    	for (int i = 5; i <= n; i++) {
					if(i%2==0) ll.add(i);
					else ll.addFirst(i);
				}
		    	for (int i : ll) {
					pw.print(i+" ");
				}
		    	pw.println();	
			}
	       }
        pw.close();
    }
	
	static PrintWriter pw=new PrintWriter(System.out);
	static char[][] grid;
	static boolean[][] visited;
	static int n,m;
	static boolean binarysearch(long[] arr,long x) {
		int start=0,end=arr.length-1;
		while (start<=end) {
			int mid=(start+end)/2;
			if (arr[mid]==x) {
				return true;
			}else if (arr[mid]>x) {
				end=mid-1;
			}else {
				start=mid+1;
			}
		}
		return false;
	}
	static long gcd(int x,int y) {
		while (x!=y) {
			if(x>y) x-=y;
			else if(x<y) y-=x;
		}
		return x;
	}
	static long lcm(int x,int y) {
		return x*y/gcd(x,y);
	}
	static int[] dx = {1, -1, 0, 0};
	static int[] dy = {0, 0, 1, -1};
	static boolean isValid(int i, int j){
		return i >= 0 && i < n && j >= 0 && j < m && grid[i][j]=='#';
	}
	static void dfs(int x, int y){
		visited[x][y] = true;
		for(int i = 0; i < 4; i++){
				if(isValid(x + dx[i], y + dy[i]) && !visited[x + dx[i]][y + dy[i]]){
					dfs(x + dx[i], y + dy[i]);
				}	
			}
	}
 
	static class Pair{
        int x;
        int y;
        public Pair(int x,int y){
            this.x= x;
            this.y = y;
        }
        public String toString(){
            return x+" " + y;
        }
 
    }
 	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
 
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return false;
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
	}
 
}