#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;
}

### Prompt

Please formulate a Cpp solution to the following problem:

Yeah, we failed to make up a New Year legend for this problem.

A permutation of length n is an array of n integers such that every integer from 1 to n appears in it exactly once. 

An element y of permutation p is reachable from element x if x = y, or p_x = y, or p_{p_x} = y, and so on. 

The decomposition of a permutation p is defined as follows: firstly, we have a permutation p, all elements of which are not marked, and an empty list l. Then we do the following: while there is at least one not marked element in p, we find the leftmost such element, list all elements that are reachable from it in the order they appear in p, mark all of these elements, then cyclically shift the list of those elements so that the maximum appears at the first position, and add this list as an element of l. After all elements are marked, l is the result of this decomposition.

For example, if we want to build a decomposition of p = [5, 4, 2, 3, 1, 7, 8, 6], we do the following:

  1. initially p = [5, 4, 2, 3, 1, 7, 8, 6] (bold elements are marked), l = []; 
  2. the leftmost unmarked element is 5; 5 and 1 are reachable from it, so the list we want to shift is [5, 1]; there is no need to shift it, since maximum is already the first element; 
  3. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1]]; 
  4. the leftmost unmarked element is 4, the list of reachable elements is [4, 2, 3]; the maximum is already the first element, so there's no need to shift it; 
  5. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3]]; 
  6. the leftmost unmarked element is 7, the list of reachable elements is [7, 8, 6]; we have to shift it, so it becomes [8, 6, 7]; 
  7. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3], [8, 6, 7]]; 
  8. all elements are marked, so [[5, 1], [4, 2, 3], [8, 6, 7]] is the result. 



The New Year transformation of a permutation is defined as follows: we build the decomposition of this permutation; then we sort all lists in decomposition in ascending order of the first elements (we don't swap the elements in these lists, only the lists themselves); then we concatenate the lists into one list which becomes a new permutation. For example, the New Year transformation of p = [5, 4, 2, 3, 1, 7, 8, 6] is built as follows:

  1. the decomposition is [[5, 1], [4, 2, 3], [8, 6, 7]]; 
  2. after sorting the decomposition, it becomes [[4, 2, 3], [5, 1], [8, 6, 7]]; 
  3. [4, 2, 3, 5, 1, 8, 6, 7] is the result of the transformation. 



We call a permutation good if the result of its transformation is the same as the permutation itself. For example, [4, 3, 1, 2, 8, 5, 6, 7] is a good permutation; and [5, 4, 2, 3, 1, 7, 8, 6] is bad, since the result of transformation is [4, 2, 3, 5, 1, 8, 6, 7].

Your task is the following: given n and k, find the k-th (lexicographically) good permutation of length n.

Input

The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.

Then the test cases follow. Each test case is represented by one line containing two integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 10^{18}).

Output

For each test case, print the answer to it as follows: if the number of good permutations of length n is less than k, print one integer -1; otherwise, print the k-th good permutation on n elements (in lexicographical order).

Example

Input


5
3 3
5 15
4 13
6 8
4 2


Output


2 1 3 
3 1 2 5 4 
-1
1 2 6 3 4 5 
1 2 4 3 

### Response

```cpp
#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;
}

```