Almost Sorted
Seiji Maki doesn't only like to observe relationships being unfolded, he also likes to observe sequences of numbers, especially permutations. Today, he has his eyes on almost sorted permutations.A permutation $$$a_1, a_2, \dots, a_n$$$ of $$$1, 2, \dots, n$$$ is said to be almost sorted if the condition $$$a_{i + 1} \ge a_i - 1$$$ holds for all $$$i$$$ between $$$1$$$ and $$$n - 1$$$ inclusive.Maki is considering the list of all almost sorted permutations of $$$1, 2, \dots, n$$$, given in lexicographical order, and he wants to find the $$$k$$$-th permutation in this list. Can you help him to find such permutation?Permutation $$$p$$$ is lexicographically smaller than a permutation $$$q$$$ if and only if the following holds: in the first position where $$$p$$$ and $$$q$$$ differ, the permutation $$$p$$$ has a smaller element than the corresponding element in $$$q$$$.
For the first and second test, the list of almost sorted permutations with $$$n = 1$$$ is $$$\{[1]\}$$$.For the third and fifth test, the list of almost sorted permutations with $$$n = 3$$$ is $$$\{[1, 2, 3], [1, 3, 2], [2, 1, 3], [3, 2, 1]\}$$$.
The first line contains a single integer $$$t$$$ ($$$1\le t\le 1000$$$) — the number of test cases.Each test case consists of a single line containing two integers $$$n$$$ and $$$k$$$ ($$$1 \le n \le 10^5$$$, $$$1 \le k \le 10^{18}$$$).It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
For each test case, print a single line containing the $$$k$$$-th almost sorted permutation of length $$$n$$$ in lexicographical order, or $$$-1$$$ if it doesn't exist.
def dfs(l, r, k, dir):
    if l == r:
        dir.append(1)
        return
    mid = l + r >> 1
    if k > mid:
        dir.append(-1)
        dfs(mid + 1, r, k, dir)
    else:
        dir.append(1)
        dfs(l, mid, k, dir)

def test():
    (n, k) = [int(i) for i in input().split()]
    if 2 ** (n - 1) < k:
        return -1
    dir = [0]
    x = n
    while x > 64:
        x -= 1
        dir.append(1)
    dfs(1, 2 ** (x - 1), k, dir)
    result = []
    buf = []
    i = 1
    while i <= n:
        if dir[i] == 1:
            result.append(i)
            i += 1
        else:
            j = i
            while j <= n and dir[j] == -1:
                j += 1
            result += list(range(j, i - 1, -1))
            i = j + 1
    return ' '.join([str(i) for i in result])
t = int(input())
while t > 0:
    t -= 1
    print(test())
def dfs(x, n, k):
    if x > n:
        return []
    if k == 0:
        return [i for i in range(x, n + 1)]
    if n - x > 64:
        buf = []
        while n - x > 64:
            buf += [x]
            x += 1
        return buf + dfs(x, n, k)
    if 2 ** (n - x) == k + 1:
        return [i for i in range(n, x - 1, -1)]
    buf = [x]
    x += 1
    cnt = 2 ** (n - x)
    while k >= cnt:
        buf += [x]
        x += 1
        k -= cnt
        cnt //= 2
    return buf[::-1] + dfs(x, n, k)

def test():
    (n, k) = [int(i) for i in input().split()]
    if 2 ** (n - 1) < k:
        return -1
    return ' '.join([str(i) for i in dfs(1, n, k - 1)])
t = int(input())
while t > 0:
    t -= 1
    print(test())
def solve(n, k):
    Exp = n - 1
    resp = ''
    respAux = ''
    expK = CalcularExponente(k)
    restoK = k - 2 ** expK
    if expK > Exp or (expK == Exp and restoK > 0):
        return -1
    for i in range(n):
        Exp -= 1
        respAux = ' ' + str(i + 1) + respAux
        if expK > Exp or (expK == Exp and restoK > 0):
            recalculoK = 2 ** expK - 2 ** Exp + restoK
            expK = CalcularExponente(recalculoK)
            restoK = recalculoK - 2 ** expK
        else:
            resp += respAux
            respAux = ''
    resp += respAux
    return resp[1:]

def CalcularExponente(k):
    kValue = k
    expK = -1
    while k > 0:
        expK += 1
        k = k // 2
    return expK

def main():
    t = int(input())
    for i in range(int(t)):
        (n, k) = input().split(' ')
        print(solve(int(n), int(k)))
main()