A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).

For a positive integer n, we call a permutation p of length n good if the following condition holds for every pair i and j (1 ≤ i ≤ j ≤ n) — 

  * (p_i  OR  p_{i+1}  OR  …  OR  p_{j-1}  OR  p_{j}) ≥ j-i+1, where OR denotes the [bitwise OR operation.](https://en.wikipedia.org/wiki/Bitwise_operation#OR)



In other words, a permutation p is good if for every subarray of p, the OR of all elements in it is not less than the number of elements in that subarray. 

Given a positive integer n, output any good permutation of length n. We can show that for the given constraints such a permutation always exists.

Input

Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.

The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).

Output

For every test, output any good permutation of length n on a separate line. 

Example

Input


3
1
3
7


Output


1
3 1 2
4 3 5 2 7 1 6

Note

For n = 3, [3,1,2] is a good permutation. Some of the subarrays are listed below. 

  * 3 OR 1 = 3 ≥ 2 (i = 1,j = 2) 
  * 3 OR 1 OR 2 = 3 ≥ 3 (i = 1,j = 3) 
  * 1 OR 2 = 3 ≥ 2 (i = 2,j = 3) 
  * 1 ≥ 1 (i = 2,j = 2) 



Similarly, you can verify that [4,3,5,2,7,1,6] is also good.
//Written by Shagoto
import java.util.*;
public class Main
{
// -------- Generating Prime Numbers Using Bit-wise sieve --------  
//  static ArrayList<Integer> primes = new ArrayList<Integer>();
//  static BitSet bs = new BitSet(10000001);
//  static void sieve()
//  {
//    primes.add(2);
//    for(int i = 4; i<=10000000; i+=2)
//    {
//      bs.set(i,true);
//    }
//    
//    for(int i = 3; i<=10000000; i+=2)
//    {
//      if(!bs.get(i))
//      {
//        primes.add(i);
//        for(int j = 3; i*j<=10000000; j+=2)
//        {
//          bs.set(i*j,true);
//        }
//      }
//    }
//  }

// -------- Phi Function --------
//  static int phi(int n) 
//  { 
//    int ret = n;  
//    for(int i = 2; i*i <= n; i++) 
//    { 
//      if(n % i == 0)  
//      { 
//        while(n % i == 0) 
//        {
//          n /= i; 
//        }
//        ret -= ret / i; 
//      } 
//    } 
//    
//    if(n > 1) 
//    {
//      ret -= ret / n; 
//    }
//    return ret; 
//  }

// -------- GCD of Two Numbers --------  
//  static int gcd(int a, int b)
//  {
//    if(b == 0)
//    {
//      return a;
//    }
//    return gcd(b, a % b);  
//  }
  
//  -------- Binary Search --------
//  static int binarySearch(int [] arr, x)
//  {
//    int low = 0;
//    int high = arr.length - 1;
//    
//    while(low <= high)
//    {
//      int mid = (low + high) / 2;
//      
//      if(arr[mid] == x)
//      {
//        return mid;
//      }
//      else if(arr[mid] > x)
//      {
//        high = mid - 1;
//      }
//      else
//      {
//        low = mid + 1;
//      }
//    }
//    return -1;
//  }
  
  public static void main(String[]args)
  {
/*
*  InputStreamReader isr = new InputStreamReader(System.in);
*  BufferedReader read = new BufferedReader(isr);
*/
    Scanner read = new Scanner(System.in); 
    
    int t = read.nextInt();
    for(int x = 1; x<=t; x++)
    {
      int n = read.nextInt();
      
      for(int i = 1; i<=n; i++)
      {
        System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}

// -------- Creating own Class --------
//class className
//{
//  int v1;
//  int v2;
//  public className(int x, int y)
//  {
//    v1 = x;
//    v2 = y;
//  }
// 
//  public String toString()
//  {
//    return v1+" "+v2;
//  }
//}

// -------- For Comparision or Sorting --------
// *Paste it in the main class*
//Collections.sort(arr, new Comparator<className>(){
//      public int compare(className a, className b)
//      {
//        if(a.v1 == b.v1)
//        {
//          return b.v2 - a.v2;
//        }
//        else
//        {
//          return a.v1 - b.v1;
//        }
//      }
//    });