#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <assert.h>

#define IOS ios::sync_with_stdio(false)

using namespace std;

#define inf (0x3f3f3f3f)

typedef long long int LL;

#include <iostream>

#include <sstream>

#include <vector>

#include <set>

#include <map>

#include <queue>

#include <string>

#include <bitset>

const int maxn = 1e5 + ;

vector<int>G[maxn];

int findmin(int len) {

    if (len == ) return ;

    if (len == ) return ;

    return (len - ) * ;

}

LL findmax(int len) {

    return 1LL * len * (len - ) / ;

}

struct node {

    int cnt, deep;

    node(int a, int b) : cnt(a), deep(b) {}

};

queue<struct node> que;

int val;

int ans[maxn];

void show(int id) {

    if (G[id].size() == ) {

        ans[id] = val;

//        cout << val << " ";

        ++val;

        return;

    }

    show(G[id][]);

    ans[id] = val;

//    cout << val << " ";

    ++val;

    if (G[id].size() == ) {

        show(G[id][]);

    }

}

int check(vector<int> arr) {

    if (arr.size() <= ) return ;

    vector<int> les;

    vector<int> big;

    for (int i = ; i < arr.size(); ++i) {

        if (arr[i] > arr[]) big.push_back(arr[i]);

        else les.push_back(arr[i]);

    }

    return check(les) + check(big) + arr.size() - ;

}

int len, c;

void bfs(int cur) {

    queue<int>que;

    que.push(cur);

//    vector<int>t;

    while (!que.empty()) {

        int now = que.front();

        que.pop();

        cout << ans[now] << " ";

//        t.push_back(ans[now]);

        for (int i = ; i < G[now].size(); ++i) {

            que.push(G[now][i]);

        }

    }

//    if (check(t) != c) {

//        cout << "NO" << endl;

//    } else cout << "YES" << endl;

}

int deep[maxn];

void work() {

    cin >> len >> c;

    if (c > findmax(len)) {

        cout << - << endl;

        return;

    }

    LL cur = findmax(len);

    for (int i = ; i <= len; ++i) {

        G[i].clear();

        if (i != len) {

            G[i].push_back(i + );

        }

        deep[i] = i - ;

    }

    while (!que.empty()) que.pop();

    que.push(node(, ));

    int impo = ;

    for (int i = len; i >=  && cur > c; --i) {

        struct node t = que.front();

        int one = i - t.deep - ;

        int to = min(cur - c, one * 1LL);

        if (to <= ) {

            cout << - << endl;

            return;

        }

        if (one == to) {

            G[t.cnt].push_back(i);

            deep[i] = deep[t.cnt] + ;

            G[i].clear();

            G[i - ].clear();

            if (G[t.cnt].size() == ) {

                if (t.cnt == impo) impo++;

                que.pop();

                que.push(node(G[t.cnt][], t.deep + ));

                que.push(node(G[t.cnt][], t.deep + ));

            }

        } else {

            G[i].clear();

            G[i - ].clear();

            for (int j = ; j <= len; ++j) {

                if (deep[i] == deep[j] + to + ) {

                    G[j].push_back(i);

                    break;

                }

            }

            break;

        }

        cur -= to;

    }

    val = ;

    show();

    bfs();

//    vector<int> t;

//    for (int i = 1; i <= len; ++i) {

//        cout << ans[i] << " ";

//        t.push_back(ans[i]);

//    }

//    cout << "****" << check(t);

    cout << endl;

}

int main() {

#ifdef local

    freopen("data.txt", "r", stdin);

//    freopen("data.txt", "w", stdout);

#endif

    int t;

    scanf("%d", &t);

    while (t--) work();

    return ;

}