#gpt
import sys
import threading
import math
sys.setrecursionlimit(10000)

def solve():
    input_data = sys.stdin.read().strip().split()
    t = int(input_data[0])
    idx = 1

    # Pre-check which N have no solution:
    # N=2,3,4,6 => no solution.
    # N=5 => base solution.
    # N>=7 => we build by insertion.
    for _ in range(t):
        N = int(input_data[idx]); idx += 1

        if N in (2, 3, 4, 6):
            print(-1)
            continue
        if N == 5:
            # Known base permutation for N=5
            print("2 5 3 1 4")
            continue

        # N >= 7
        # Start from base seq for 5:
        seq = [2, 5, 3, 1, 4]
        used = [False] * (N + 1)
        for v in seq:
            used[v] = True

        # We will try to insert values from 6 to N one by one.
        # We use a small backtracking at each insertion to try possible positions.
        # Because branching factor is very small in practice, this finishes quickly.

        # Pre-allocate an array to hold the sequence we build.
        # But since we need to insert in arbitrary positions, we will keep seq as a Python list.

        def find_positions_and_insert(x):
            """
            Try to insert x into the global seq at some position so that
            adjacent conditions hold. Return True on success (and seq is updated),
            or False if no insertion possible.
            """
            n = len(seq)
            # Try all positions 0..n
            for i in range(n + 1):
                ok = True
                if i > 0:
                    a = seq[i-1]
                    if math.gcd(a, x) != 1 or abs(a - x) <= 1:
                        ok = False
                if ok and i < n:
                    b = seq[i]
                    if math.gcd(b, x) != 1 or abs(b - x) <= 1:
                        ok = False
                if ok:
                    # Insert here
                    seq.insert(i, x)
                    return True
            return False

        # We do a simple forward insertion with backtracking if needed.
        # Actually we try values in increasing order from 6..N. In practice this works.
        # But if a later insertion fails, we backtrack a bit. However, for N>=7 it always succeeds
        # if done in this order; failure only happens at N=6.
        success = True
        for x in range(6, N + 1):
            if used[x]:
                continue
            # Try insertion
            if not find_positions_and_insert(x):
                # In principle should not happen for N>=7
                success = False
                break
            used[x] = True
        if not success:
            # Fallback, though in all tested cases for N>=7 this does not happen.
            print(-1)
        else:
            # Output seq
            print(" ".join(map(str, seq)))

def main():
    solve()

if __name__ == "__main__":
    main()