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 javax.print.attribute.SupportedValuesAttribute;
import java.io.*;
import java.lang.reflect.Array;
import java.security.interfaces.DSAKeyPairGenerator;
import java.util.*;
import java.util.function.Predicate;


public class Main{

    static class TaskB {
        public void solve(InputReader in, PrintWriter out) {
            int T = in.nextInt();
            for(int tt= 0; tt < T; tt++)
            {
                int num = in.nextInt();
                for(int i = 1; i <= num; i++)
                {
                    out.print(i+" ");
                }
                out.println();
            }
        }
    }

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(in, out);
        out.close();
    }


    static class Graph
    {
        int V;
        LinkedList<Integer>[] adj;
        HashMap<String, Integer> convert;
        int stringName;
        boolean[] color;
        Graph(int V)
        {
            this.V = V;
            color = new boolean[V];
            adj = new LinkedList[V];
            convert = new HashMap<>();
            stringName = 0;

            for(int i = 0; i < V; i++)
            {
                adj[i] = new LinkedList<>();
            }
        }

        void addEdge(String v, String u)
        {
            if(!convert.containsKey(v))
            {
                convert.put(v, stringName);
                stringName++;
            }
            if(!convert.containsKey(u))
            {
                convert.put(u, stringName);
                stringName++;
            }
            addEdge(convert.get(v), convert.get(u));
        }

        void addEdge(int v, int u)
        {
            adj[v].add(u);
            //adj[u].add(v);  //USE IN UNDIRECTED GRAPHS
        }

        void color(int v) {
            for (int i : adj[v]) {
                color[i] = !color[v];
                color(i);
            }
        }

    }


    static void sort(int[] a)
    {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i: a)list.add(i);
        Collections.sort(list);
        for(int i = 0; i < a.length; i++)a[i]=list.get(i);
    }


    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer = new StringTokenizer("");

        public InputReader(InputStream inputStream) {
            this.reader = new BufferedReader(
                    new InputStreamReader(inputStream));
        }

        public String next() {
            while (!tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
    }
}