def absolutePermutation(n, k):
    res = []
    used = set()
    for index in range(1, n + 1):
        lower_option = index - k
        upper_option = index + k
        if lower_option > 0 and lower_option not in used:
            res.append(lower_option)
            used.add(lower_option)
        elif upper_option <= n and upper_option not in used:
            res.append(upper_option)
            used.add(upper_option)
        else:
            return [-1]
    return res

def absolutePermutation(n, k):
    if k == 0: return list(range(1,n+1))
    if (n/k)%2 != 0: return [-1]
    res = []
    up = True
    for i in range(n//k):
        for j in range(k):
            res.append(i*k+1+j + (k if up else -k))
        up = not up
        
        
    return  res

    P = [0]*(n+1)
    # Try to create P that fulfills |P[i] - i| = k
    for i in range(1,n+1):
        if P[i] == 0:
            # P[i] can be either i+k or i-k.
            # Greedy approach, try to fit the lexicographically smallest first
            if i-k > 0 and P[i-k] == 0:
                P[i], P[i-k] = i-k, i
            elif i+k <= n and P[i+k] == 0:
                P[i], P[i+k] = i+k, i
            else:
                # Not possible
                return [-1]
    # Skips the first element, added just for better code readability
    return P[1:]

#include <iostream>
#include <vector>
using namespace std;

vector<int> absolutePermutation(int n, int k) {
    vector<int> result;

    // If k is 0, the permutation is just the natural numbers from 1 to n.
    if (k == 0) {
        for (int i = 1; i <= n; ++i) {
            result.push_back(i);
        }
        return result;
    }

    // If n is not divisible by 2 * k, a valid permutation is not possible.
    if (n % (2 * k) != 0) {
        return {-1};
    }

    // Construct the permutation in groups of 2 * k.
    for (int i = 1; i <= n; i += 2 * k) {
        // Add the first k numbers in the group shifted by +k.
        for (int j = 0; j < k; ++j) {
            result.push_back(i + j + k);
        }
        // Add the next k numbers in the group shifted by -k.
        for (int j = 0; j < k; ++j) {
            result.push_back(i + j);
        }
    }

    return result;
}

int main() {
    int t;
    cin >> t; // Number of queries

    while (t--) {
        int n, k;
        cin >> n >> k;

        vector<int> result = absolutePermutation(n, k);

        if (result.size() == 1 && result[0] == -1) {
            cout << "-1\n";
        } else {
            for (int num : result) {
                cout << num << " ";
            }
            cout << "\n";
        }
    }

    return 0;
}