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.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main {
    private static FastScanner input;
    private static PrintWriter output;

    public static void main(String[] args) throws IOException {
//                openFile();
        openConsole();

        int numTest = readInt();
        for (int eachTest = 0; eachTest < numTest; eachTest++) {
            solve_f();
        }
        closeReader();
    }

    private static void solve_f() throws IOException {
        int n = readInt();
        if (n < 4) {
            output.println(-1);
        } else {
            for (int i = n; i >= 1; i--) {
                if (i % 2 != 0) {
                    output.print(i + " ");
                }
            }
            output.print("4 2 ");
            for (int i = 6; i <= n; i += 2) {
                output.print(i + " ");
            }
            output.println();
        }
    }

    public static long solve(List<Pair> data) {
        FenwickTree count = new FenwickTree(data.size());
        FenwickTree val = new FenwickTree(data.size());
        TreeSet<Integer> ts = new TreeSet<>();
        for (Pair eachData : data) {
            ts.add(eachData.velocity);
        }

        TreeMap<Integer, Integer> tm = new TreeMap<>();
        while (!ts.isEmpty()) {
            tm.put(ts.pollFirst(), tm.size() + 1);
        }

        data.sort(Comparator.comparingInt(a -> a.position));
        long sum = 0;
        for (Pair p : data) {
            int lim = tm.get(p.velocity);
            if (lim > 0) {
                long cntt = count.rsq(lim);
                long value = val.rsq(lim);
                sum += p.position * cntt - value;
            }
            count.point_update(lim, 1);
            val.point_update(lim, p.position);
            System.out.println(sum);
        }
        return sum;
    }

    private static long readLong() throws IOException {
        return input.nextLong();
    }

    private static String readString() throws IOException {
        return input.nextLine();
    }

    private static int readInt() throws IOException {
        return input.nextInt();
    }

    private static int[] readIntArray(int size) throws IOException {
        int[] data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = readInt();
        }
        return data;
    }

    private static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    private static void openConsole() {
        input = new FastScanner(System.in);
        output = new PrintWriter(System.out);
    }

    private static void openFile() throws FileNotFoundException {
        ClassLoader classLoader = Main.class.getClassLoader();
        File myFile = new File(classLoader.getResource("input.txt").getFile());
        input = new FastScanner(new FileInputStream(myFile));
        output = new PrintWriter(System.out);
    }

    private static void closeReader() {
        output.flush();
        output.close();
    }

    static class FenwickTree { // one-based DS
        private final int n;
        private final long[] ft;

        private FenwickTree(int size) {
            n = size;
            ft = new long[n + 1];
        }

        // O(log n)
        long rsq(int b) {
            long sum = 0;
            while (b > 0) {
                sum += ft[b];
                b -= b & -b;
            } // min?
            return sum;
        }

        long rsq(int a, int b) {
            return rsq(b) - rsq(a - 1);
        }

        // O(log n), update = increment
        void point_update(int k, int val) {
            while (k <= n) {
                ft[k] += val;
                k += k & -k;
            } // min?
        }

        // c * O(log n), c < 1
        long point_query(int idx) {
            long sum = ft[idx];
            if (idx > 0) {
                int z = idx ^ (idx & -idx);
                --idx;
                while (idx != z) {
                    sum -= ft[idx];
                    idx ^= idx & -idx;
                }
            }
            return sum;
        }
    }

    static class Pair {
        int position, velocity;

        public Pair(int aPosition, int aVelocity) {
            position = aPosition;
            velocity = aVelocity;
        }
    }

    private static class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        private String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }
}