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 Sol{
	public static void main(String[] args) throws IOException{
		FastIO sc = new FastIO(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int t = sc.nextInt();
		wh: while(t-->0) {
			int n = sc.nextInt();
			if(n==2||n==3) {
				System.out.println(-1);
				continue wh;
			}
			if(n==4) {
				System.out.println(3 + " " + 1 + " " + 4 + " " + 2);
			}else {
				int ans[] = new int[n];
				int curr =1;
				int idx = 0;
				while(curr<=n) {
					ans[idx] = curr;
					idx++;
					curr+=2;
				}
				
				if(n%2==1) {
					curr = n-3;
					ans[idx] = curr;
					curr = n-1;
					idx++;
					ans[idx] = curr;
					idx++;
					curr-=4;
					while(curr>0) {
						ans[idx] = curr;
						curr-=2;
						idx++;
					}
				}else {
					curr = n-4;
					ans[idx] = curr;
					curr = n;
					idx++;
					ans[idx] = curr;
					idx++;
					curr = n-2;
					ans[idx] = curr;
					idx++;
					curr-=4;
					while(curr>0) {
						ans[idx] = curr;
						curr-=2;
						idx++;
					}
				}
				for(int i=0; i<n; i++) {
					System.out.print(ans[i] + " ");
				}
				System.out.println();
			}
 		}
		out.close();
	}
    public static void ColumnSort(int arr[][], int col) { 
        Arrays.sort(arr, new Comparator<int[]>() { 
            @Override 
          public int compare(int[] entry1,  
                             int[] entry2) { 
            	Integer a = entry1[col];
            	Integer b = entry2[col];
            	return a.compareTo(b);
          } 
        }); 
    } 
	static class FastIO {
		 
		// Is your Fast I/O being bad?
 
		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;
 
		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}
 
		public FastIO(InputStream is) throws IOException {
			dis = is;
		}
 
		int nextInt() throws IOException {
			int ret = 0;
 
			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
 
			return (negative) ? -ret : ret;
		}
 
		long nextLong() throws IOException {
			long ret = 0;
 
			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
 
			return (negative) ? -ret : ret;
		}
 
		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}
 
		String next() throws IOException {
			StringBuffer ret = new StringBuffer();
 
			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}
 
			return ret.toString();
		}
 
	}
}