import sys
import threading
from math import gcd

def find_beautiful_permutation(N):
    # build adjacency list: edge u–v if gcd(u,v)==1 and |u−v|>1
    adj = [[] for _ in range(N+1)]
    for u in range(1, N+1):
        for v in range(u+1, N+1):
            if abs(u - v) > 1 and gcd(u, v) == 1:
                adj[u].append(v)
                adj[v].append(u)

    # sort neighbors by ascending degree to help prune early
    deg = [len(adj[u]) for u in range(N+1)]
    for u in range(1, N+1):
        adj[u].sort(key=lambda x: deg[x])

    visited = [False] * (N+1)
    path = [0] * N

    sys.setrecursionlimit(10**7)
    def dfs(pos):
        if pos == N:
            return True
        last = path[pos-1]
        for v in adj[last]:
            if not visited[v]:
                visited[v] = True
                path[pos] = v
                if dfs(pos+1):
                    return True
                visited[v] = False
        return False

    # try every possible start
    for start in range(1, N+1):
        visited[start] = True
        path[0] = start
        if dfs(1):
            return path[:]
        visited[start] = False

    return []  # no solution

def main():
    data = sys.stdin.read().split()
    T = int(data[0])
    idx = 1
    out = []
    for _ in range(T):
        N = int(data[idx]); idx += 1

        # impossible small cases
        if N in (2, 3, 4, 6):
            out.append("-1")
            continue

        sol = find_beautiful_permutation(N)
        if not sol:
            out.append("-1")
        else:
            out.append(" ".join(map(str, sol)))

    sys.stdout.write("\n".join(out))

if __name__ == "__main__":
    # run in a separate thread to allow deep recursion
    threading.Thread(target=main).start()