#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
  a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
  a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
  cin >> x;
}
void re(double& x) {
  string t;
  re(t);
  x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
  re(first);
  re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
  re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
  for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
  for (int i = 0; i < (SZ); i++) re(a[i]);
}
}  // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
  pr(first);
  pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
  if (pretty) pr("{");
  bool fst = 1;
  for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
  if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
  prContain<T, false>(x);
  pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
  prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
  prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
  prContain(x);
}
template <class T>
void pr(const set<T>& x) {
  prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
  pr(first);
  ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
  pr(first, " ");
  ps(rest...);
}
}  // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
  sort((v).begin(), (v).end());
  v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
  auto it = lower_bound((v).begin(), (v).end(), x);
  return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
  auto it = find(v, x);
  assert(it != v.end() && *it == x);
  return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
  vector<T> r(int((v).size()) + 1, id);
  for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
  return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
  vector<T> r(int((v).size()) + 1, id);
  for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
  return r;
}
}  // namespace __algorithm
using namespace __algorithm;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
struct monostate {
  friend istream& operator>>(istream& is, const monostate& ms) { return is; }
  friend ostream& operator<<(ostream& os, const monostate& ms) { return os; }
  friend monostate operator+(const monostate& a, const monostate& b) {
    return a;
  }
} ms;
#pragma GCC diagnostic pop
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(15);
  if (int((second).size())) {
    setIn(second + ".in"), setOut(second + ".out");
  }
}
}  // namespace __io
using namespace __io;
const int MAXL = 51;
ll fact[MAXL], good_ct[MAXL];
const ll INF = 1e18 + 123;
ll add(ll a, ll b) { return min(INF, a + b); }
ll mult(ll a, ll b) { return INF / a <= b ? INF : min(INF, a * b); }
ll good(const vi& pref, int fi) {
  if (int((pref).size()) == fi || pref[fi] == -1)
    return good_ct[int((pref).size()) - fi];
  vi cyc0 = {fi};
  for (int i = pref[fi]; ~i; i = pref[i]) {
    if (i == fi) {
      if (*max_element((cyc0).begin(), (cyc0).end()) != pref[fi]) return 0;
      if (pref[fi] + 1 != fi + int((cyc0).size())) return 0;
      return good(pref, fi + int((cyc0).size()));
    } else
      cyc0.push_back(i);
  }
  int MS = *max_element(pref.begin() + fi, pref.end()) + 1;
  if (MS != pref[fi] + 1) return 0;
  vi tail(MS, -1);
  for (auto& e : cyc0) tail[e] = cyc0.back();
  for (int i = (fi); i < (MS); i++)
    if (!~tail[i]) {
      int ti = i;
      while (!~tail[ti] && ~pref[ti]) {
        ti = pref[ti];
        if (ti == i) return 0;
      }
      if (!~tail[ti]) tail[ti] = ti;
      for (int j = i; j != ti; j = pref[j]) tail[j] = tail[ti];
    }
  vi is_tail(MS);
  for (auto& e : tail)
    if (~e) is_tail[e] = 1;
  int tails = accumulate((is_tail).begin(), (is_tail).end(), 0);
  return mult(fact[tails - 1], good_ct[int((pref).size()) - MS]);
}
void solve() {
  int N;
  ll K;
  re(N, K);
  K--;
  vi ans(N, -1);
  set<int> avail;
  for (int i = 0; i < (N); i++) avail.insert(i);
  for (int i = 0; i < (N); i++) {
    bool done = 0;
    for (auto& e : avail) {
      ans[i] = e;
      ll ct = good(ans, 0);
      if (ct <= K)
        K -= ct;
      else {
        done = 1;
        break;
      }
    }
    if (!done) {
      ps(-1);
      return;
    }
    avail.erase(ans[i]);
  }
  if (K != 0 || good(ans, 0) == 0)
    ps(-1);
  else {
    for (auto& e : ans) ++e;
    pc(ans);
  }
}
int main() {
  setIO();
  fact[0] = 1;
  for (int i = (1); i < (MAXL); i++) fact[i] = mult(i, fact[i - 1]);
  good_ct[0] = 1;
  for (int l = (1); l < (MAXL); l++) {
    for (int i = (1); i < (l + 1); i++)
      good_ct[l] = add(good_ct[l], mult(good_ct[l - i], fact[max(0, i - 2)]));
  }
  int T;
  re(T);
  for (int t = 0; t < (T); t++) {
    solve();
  }
  return 0;
}
