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.
import java.lang.*;
import java.util.*;

public class ct1 {

    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) {
            val = x;
            left=null;
            right=null;
        }
    }

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
            next = null;
        }
    }

    public static List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        ArrayList<String> a = new ArrayList<>();
        for(int i=0; i<strs.length; i++){
            int f=0, j=0;
            for(j=0; j<a.size(); j++){
                char[] x = strs[i].toCharArray();
                Arrays.sort(x);
                String temp = new String(x);
                if(temp.equals(a.get(j))){
                    f=1;
                    break;
                }
            }
            if(f==1){
                res.get(j).add(strs[i]);
            }
            else{
                ArrayList<String> tt = new ArrayList<>();
                char[] x = strs[i].toCharArray();
                Arrays.sort(x);
                String temp = new String(x);
                tt.add(temp);
                res.add(tt);
            }
        }
        return res;
    }


    static class pair{
        int val, count;
        pair(int val, int count){
            this.val = val;
            this.count = count;
        }
    }

    public static void main(String[] args) {
        Scanner inp = new Scanner(System.in);
        int n = inp.nextInt();
        while(n-->0){
            int x = inp.nextInt();
            ArrayList<Integer> a = new ArrayList<>();
            if(x%2!=0) {
                for (int i = x / 2 + 1; i <= x; i++)
                    a.add(i);
                int i = x / 2, j = 1;
                while (j < a.size()) {
                    a.add(j, i--);
                    j += 2;
                }
                for (i = 0; i < a.size(); i++)
                    System.out.print(a.get(i) + " ");
            }
            else {
                for (int i = x / 2 + 1; i <= x; i++)
                    a.add(i);
                int i = x / 2, j = 1;
                while (j < a.size()) {
                    a.add(j, i--);
                    j += 2;
                }
                a.add(1);
                for (i = 0; i < a.size(); i++)
                    System.out.print(a.get(i) + " ");
            }
            System.out.println();
        }

    }

    static class Interval{
        int start, end;
        Interval(int start, int end){
            this.end= end;
            this.start = start;
        }
    }

    static class sort implements Comparator<Interval>{
        public int compare(Interval i1, Interval i2){
            return i1.start - i2.start;
        }
    }
    public static int minMeetingRooms(List<Interval> intervals) {
        Collections.sort(intervals, new sort());
        ArrayList<Interval> a = new ArrayList<>();
        a.add(intervals.get(0));
        for(int i=1; i<intervals.size(); i++){
            boolean added = false;
            for(int j=0; j<a.size(); j++){
                if(a.get(j).end <= intervals.get(i).start){
                    a.set(j, intervals.get(i));
                    break;
                }
            }
            if(!added){
                a.add(new Interval(intervals.get(i).start, intervals.get(i).end));
            }
        }
        return a.size();
    }

    static int bs(int[] n, int s, int e){
        if(s>=e)
            return n[s];
        int middle = (s+e)/2;
        if(s!=0 && n[s-1]>n[s])
            return n[s];
        else if(n[e]<n[s])
            return bs(n, middle+1, e);
        else
            return bs(n, s, middle-1);
    }

    public static int findMin(int[] nums) {
        return bs(nums, 0, nums.length-1);
    }

    public static int subarraySum(int[] nums, int k) {
        int res = 0, csum=0, i=0, j=0;
        csum+=nums[j];
        while(j<nums.length){
            if(i>j){
                j=i;
                if(j>nums.length)
                    break;
                csum = nums[i];
            }
            else if(csum == k){
                res++;
                csum-=nums[i];
                i++;
            }
            else if(csum<k){
                j++;
                if(j<nums.length){
                    csum+=nums[j];
                }
            }
            else if(csum>k){
                csum-=nums[i];
                i++;
            }
        }
        return res;
    }

    public static int firstUniqChar(String s) {
        LinkedHashMap<Character, Integer> a = new LinkedHashMap<>();
        for(int i=0; i<s.length(); i++){
            if(a.get(s.charAt(i))==null){
                a.put(s.charAt(i), 1);
            }
            else{
                a.put(s.charAt(i), a.get(s.charAt(i))+1);
            }
        }
        for(Map.Entry<Character, Integer> ss:a.entrySet()){
            if(ss.getValue().equals(1))
                return (char)(ss.getKey());
        }
        return -1;
    }

    static class KthLargest {

        TreeMap<Integer, Integer> tm = new TreeMap<>();
        int k =0;
        public KthLargest(int k, int[] nums) {
            this.k = k;
            for(int i=0; i<nums.length; i++){
                if(tm.get(nums[i]) == null){
                    tm.put(nums[i], 1);
                }
                else{
                    tm.put(nums[i], tm.get(nums[i])+1);
                }
            }
        }

        public int add(int val) {
            if(tm.get(val) == null){
                tm.put(val, 1);
            }
            else{
                tm.put(val, tm.get(val)+1);
            }
            ArrayList<Integer> y = new ArrayList<>();
            int temp = 0;
            temp+=(k-1);
            int res = 0;
            while(temp-->0){
                int x = tm.lastKey();
                if(tm.get(x) == 1){
                    y.add(x);
                    tm.remove(x);
                }
                else{
                    tm.put(x, tm.get(x)-1);
                }
            }
            res = tm.lastKey();
            for(int i=0; i<y.size(); i++){
                if(tm.get(y.get(i)) == null){
                    tm.put(y.get(i), 1);
                }
                else{
                    tm.put(y.get(i), tm.get(y.get(i))+1);
                }
            }
            return res;
        }
    }

    static long binaryToDecimal(String n)
    {
        String num = n;
        long dec_value = 0;

        // Initializing base value to 1,
        // i.e 2^0
        long base = 1;

        int len = num.length();
        for (int i = len - 1; i >= 0; i--) {
            if (num.charAt(i) == '1')
                dec_value += base;
            base = base * 2;
        }

        return dec_value;
    }


    static HashSet<String> a = new HashSet<>();
    static HashSet<Integer> b = new HashSet<>();
    public static boolean wordBreak(String s, List<String> w) {
        for(int i=0; i<w.size(); i++){
            a.add(w.get(i));
        }
        return res(s, 0, s.length());
    }

    static boolean res(String s, int i, int j){
        if(a.contains(s.substring(i, j)))
            return true;
        if(b.contains(i))
            return true;
        for(int k=i+1; k<j; k++){
            if(a.contains(s.substring(0, k)))
                if(res(s, k, j)){
                    b.add(i);
                    return true;
                }
        }
        return false;
    }




}