Problem: You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:

  1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one; 
  2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i. 



Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:

  1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0]; 
  2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0]; 
  3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0]; 
  4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0]; 
  5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5]. 



Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.

The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).

Output

For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.

Example

Input


6
1
2
3
4
5
6


Output


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

Solution (in PYTHON3):

Solution:
"""
    This template is made by Satwik_Tiwari.
    python programmers can use this template :)) .
"""

#===============================================================================================
#importing some useful libraries.

import sys
import bisect
import heapq
from math import *
from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl #
from bisect import bisect_right as br
from bisect import bisect

#===============================================================================================
#some shortcuts

mod = pow(10, 9) + 7
def inp(): return sys.stdin.readline().strip() #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)


#===============================================================================================
# code here ;))

def func(a):
    return [a[1] - a[0]]

def solve():
    n = int(inp())
    # n=9
    a = []

    if(n==1):
        print(1)
    elif(n==2):
        print(1,2)
    else:
        k=1
        while ((2**k) <= n):
            k+=1
        k = 2**k
        # print(k)
        for i in range(0,k+1):
            if(i==1):
                a.append([1,n])
                continue
            a.append([0,0])
        f = 0
        for i in range(1,k+1):
            if(a[i][0] == a[i][1]):
                continue
            if((a[i][1]  - a[i][0]+1)%2==1):
                temp = (a[i][0]+a[i][1])//2
            else:
                temp = (a[i][0]+a[i][1]-1)//2
            # print(i)
            if(a[i][0]<=temp-1):
                a[2*i] = [a[i][0],temp-1]
            if(temp+1<= a[i][1]):
                a[(2*i)+1] = [temp+1,a[i][1]]

        # print(a)
        # x = 1
        # while(2**x<n):
        #     temp = []
        #     for i in range(2**x,2**(x+1)):
        #         temp.append(a[i])
        #     temp = sorted(temp,key=func,reverse = True)[::-1]
        #     a = a[:2**x] + temp[::-1] + a[2**(x+1):]
        #     x+=1
        # # print(a)
        a = sorted(a,key=func)[::-1]
        final = []
        for i in range(0,len(a)):
            if(a[i][0] != 0 and a[i][1] !=0):
                final.append(a[i])
        # print(final)

        ok = []
        temp = []
        for i in range(0,len(final)):
            if(i==0):
                temp.append(final[i])
                diff = final[i][1] - final[i][0]
            elif(final[i][1]-final[i][0] == diff):
                temp.append(final[i])
            else:
                temp = sorted(temp)
                ok += temp
                temp = []
                diff = final[i][1] -final[i][0]
                temp.append(final[i])
            if(i==len(final)-1):
                temp = sorted(temp)
                ok +=  temp
        # print(ok)


        ans = [0]*(n+1)
        for i in range(1,n+1):
            if((ok[i-1][1] - ok[i-1][0] + 1) %2==1) :
                # print((final[i-1][0] + final[i-1][1])//2,i)
                ans[(ok[i-1][0] + ok[i-1][1])//2] = i
            else:
                ans[(ok[i-1][0]+ok[i-1][1] -1)//2] = i

        print(*ans[1:])



testcase(int(inp()))
# testcase(1)