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.io.*;
import java.util.*;
public class code {
	static PrintWriter pw;
	static boolean[][] visit;
	static char[][] adj;
//	static void dfs(int i, long c) {
//		visit[i]=true;
//		max=Math.max(c, max);
//		for(Pair p: adj[i]) {
//			if(!visit[p.x-1]) {
//				dfs(p.x-1, c+1l*p.y);
//			}
//		}
//	}
//	static Queue<Integer> q;
//	static void bfs(int i) {
//		visit[i].x=true;
//		visit[i].n=0;
//		q.add(i);
//		while(!q.isEmpty()){
//			int u = q.poll();
//			for(int v : adj[u]){
//				if(!visit[v].x){
//					q.add(v);
//					visit[v].x = true;
//					visit[v].n=visit[u].n+1;
//				}
//			}
//		}
//	}
//	static void tpsort(int i) {
//		visit[i]=true;
//		for(int x: adj[i]) {
//			if(!visit[x-1]) {
//				tpsort(x-1);
//			}
//		}
//		sticks.add(i+1);
//	}
	static int max;
	static int[] dx= {1,-1,0,0};
	static int[] dy= {0,0,1,-1};
	static boolean valid(int i, int j) {
		return i<adj.length && i>=0 && j<adj.length && j>=0;
	}
	static void dfs(int i, int j) {
		visit[i][j]=true;
		max++;
		for(int k=0; k<4; k++) {
			if(valid(i+dx[k],j+dy[k]) && !visit[i+dx[k]][j+dy[k]] && (adj[i+dx[k]][j+dy[k]]=='x' || adj[i+dx[k]][j+dy[k]]=='@')) {
				dfs(i+dx[k],j+dy[k]);
			}
		}
	}
	public static boolean contain(String s) {
		for(int i=0; i<s.length(); i++)
			if(s.charAt(i)==' ')
				return true;
		return false;
	}
	public static double dist(Pair a, Pair b) {
		return Math.sqrt((a.x-b.x)*(a.x-b.x)+ (a.y-b.y)*(a.y-b.y));
	}
	public static boolean sign(int x) {
		return x>0;
	}
	static long ceildiv(long x,long y) {
		return x%y==0? x/y: x/y+1;
	}
	static boolean only(int x,int y, int z) {
		int sum=x+y+z;
		return sum==x || sum==z || sum==y;
	}
	public static void main(String[] args) throws Exception {
		Scanner sc= new Scanner(System.in);
		pw = new PrintWriter(System.out);
		int t=sc.nextInt();
		int[] even=new int[500];
		int[] odd=new int[500];
		even[0]=4;even[1]=2;
		int j=2,k=0;
		for(int i=1; i<=1000; i++) {
			if(i%2==1) {
				odd[k++]=i;
			}else {
				if(i>4) {
					even[j++]=i;
				}
			}
		}
		while(t-->0) {
			int n=sc.nextInt();
			if(n<4) {
				pw.println(-1);
				continue;
			}
			for(int i=0; i<(n+1)/2; i++) {
				pw.print(odd[(n+1)/2-i-1]+" ");
			}
			for(int i=0; i<(n)/2-1; i++) {
				pw.print(even[i]+" ");
			}
			pw.println(even[n/2-1]);
		}
		pw.close();
	}
	static class Scanner {
		StringTokenizer st;
		BufferedReader br; 
		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
 
		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}
 
		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 {
			return Double.parseDouble(next());
		}
 
		public int[] nextArr(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < arr.length; i++)
				arr[i] = nextInt();
			return arr;
		}
		public Integer[] nextsort(int n) throws IOException{
			Integer[] arr=new Integer[n];
			for(int i=0; i<n; i++) 
				arr[i]=nextInt();
			return arr;
		}
		public boolean ready() throws IOException {
			return br.ready();
		}
	}
	static class Pair implements Comparable<Pair>{
		int x;
		int y;
		public Pair(int a, int b) {
			this.x=a;
			this.y=b;
		}
		public int hashCode() {
			return (this.x+""+this.y).hashCode();
		}
		public int compareTo(Pair other) {
			if(this.x!=other.x)
				return this.x-other.x;
			else {
				return this.y-other.y;
			}
		}
		public boolean equals(Object obj) {
			if (obj == null) {
	            return false;
	        }
	        if (this.getClass() != obj.getClass()) {
	            return false;
	        }
	        Pair p=(Pair)obj;
	        return this.x==p.x && this.y==p.y;
		}
	}
	static class visit{
		boolean x;
		int n;
		public visit(){
			this.x=false;
			this.n=-1;
		}
		public int compareTo(visit other) {
			return this.n-other.n;
		}
	}
	static class Tuple implements Comparable<Tuple>{
		int x;
		int y;
		boolean d;
		public Tuple(int a, int b, boolean t) {
			this.x=a;
			this.y=b;
			this.d=t;
		}
		public int compareTo(Tuple other) {
			if(this.d && !other.d) {
				return 1;
			}else if(!this.d && other.d) {
				return -1;
			}else {
				return this.y-other.y;
			}
		}
	}
}