1279_E. New Year Permutations
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 
```python
# 1279E - New Year Permutations

# Idea:
# dp(i) --> # of good permutations of [i,n]
# cycles(m) --> # of blocks of len m ( == (m-2)! as first element is fixed)
# It is easy to test for impossibility ie.  k > dp(1)
# Another subproblem: how to compute jth smallest cycle
# getGoodPerm(n,k) uses both getCycle(b, (k/dp[n-b])) and getGoodPerm(n-b, k%dp[n-b])


# TIME LIMIT EXCEEDED

import math
from decimal import *

getcontext().prec = 50

# try to do in O(n)


# simple implementation of the union find
class DSU:
    def __init__(self, n):
        self.hash = {}
        for i in range(1, n+1):
            self.hash[i] = [i]

    def union(self, i, j):
        lst1 = self.hash[i]
        lst2 = self.hash[j]
        lst1.extend(lst2)
        for element in lst2:
            self.hash[element] = lst1

    def same_set(self, i, j):
        return j in self.hash[i]


def getKthPerm(lst, k, offset):
    if len(lst)-1 == offset:
        return True
    elif len(lst) <= offset:  # incorrect params
        return False
    else:
        n = len(lst) - offset
        #print("n,k,offset == %d, %d, %d" % (n, k, offset))
        index = (math.ceil(k/(math.factorial(n-1)))-1) + offset
        #print("index == %d" % index)
        if index >= len(lst):  # to large k
            return False

        # move element at index up front
        if index > offset:
            temp = lst[index]
            lst.pop(index)
            lst.insert(offset, temp)

        while k-math.factorial(n-1) > 0:
            k -= math.factorial(n-1)

        return getKthPerm(lst, k, offset+1)


def getKthCycle(n, k, fact):
    lst = [i-1 for i in range(n+1)]
    # num of ends that still dont have incoming link
    num_open = n

    dsu = DSU(n)
    dsu.union(1, n)
    lst[1] = n
    num_open -= 1

    pos = 2
    while pos < n:
        i = pos
        while i <= n:
            if dsu.same_set(pos, lst[i]):
                pass
            else:
                if k <= fact[num_open-2]:
                    break
                else:
                    k -= fact[num_open-2]
            i += 1

        if i == n+1:  # k is too large
            return None
        else:
            num_open -= 1

            dsu.union(pos, lst[i])

            # move the element at pos i to "pos"
            # while keeping the sorted-ness of lst
            temp = lst[i]
            j = i
            while j > pos:
                lst[j] = lst[j-1]
                j -= 1
            lst[pos] = temp

        pos += 1
    return lst[1:]


# number of cycles with n elements
def cycles(n, fact):
    if n <= 1:
        return 1
    else:
        if n-2 in fact:
            return fact[n-2]
        else:
            return math.factorial(n-2)


# number of good permutations of [i,n]
def dp(i, n, table, fact):
    if i > n:
        return 0
    elif i == n:
        return 1
    else:
        if i in table:
            return table[i]
        else:
            val = 0
            for j in range(i, n+1):
                val += dp(j+1, n, table, fact)*cycles(j-i+1, fact)
            table[i] = val
            return val


def Max(i, table, fact):
    if i in table:
        return table[i]
    else:
        if i <= 1:
            table[i] = 1
            return 1
        else:
            val = 0
            for j in range(1, i+1):
                val += Max(i-j, table, fact)*cycles(j, fact)
            table[i] = val
            return val


def getKthGoodPermutation(n, k, Max, fact):
    if Max[n] < k:  # k is too large
        return None
    if n == 1:
        if k == 1:
            return [1]
        else:
            return None

    block_len = 1
    while k - cycles(block_len, fact)*Max[n-block_len] > 0:
        k -= cycles(block_len, fact)*Max[n-block_len]
        block_len += 1

    k_block = math.ceil(Decimal(k)/Decimal(Max[n-block_len]))
    k_rem = k - (k_block - 1)*Max[n-block_len]

    new_lst = getKthCycle(block_len, k_block, fact)
    if n-block_len > 0:
        rem_lst = getKthGoodPermutation(n-block_len, k_rem, Max, fact)
        for i in range(len(rem_lst)):
            rem_lst[i] += block_len
        new_lst.extend(rem_lst)
    return new_lst


def compute_fact(n, table):
    table[0] = 1
    table[1] = 1
    x = 2
    while x <= n:
        table[x] = x*table[x-1]
        x += 1
    return


if __name__ == '__main__':
    T = int(input())
    N, K = [], []
    for _ in range(T):
        inp = input().rstrip().split(" ")
        n, k = int(inp[0]), int(inp[1])
        N.append(n)
        K.append(k)

    # prepare tables
    max_n = max(N) + 5
    fact = {}
    compute_fact(max_n, fact)

    dp_table = {}
    a = 1
    while a <= max_n:
        Max(a, dp_table, fact)
        a += 1

    j = 0
    while j < len(N):
        lst = getKthGoodPermutation(N[j], K[j], dp_table, fact)
        if lst != None:
            for i in range(len(lst)):
                lst[i] = str(lst[i])
            print(" ".join(lst))
        else:
            print("-1")
        j += 1

```