Problem: You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).

Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].

Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].

Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.

Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.

Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.

It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.

Output

For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.

It can be proven that p exists and is unique.

Example

Input


4
1 1
2 2
3 2
4 3


Output


1 
1 2 
2 1 
1 3 2 

Note

In the first test case, the sequence a = [1], there is only one permutation p = [1].

In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.

In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.

In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.

Solution (in JAVA):

Solution:

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UncheckedIOException;
import java.io.Writer;
import java.util.Arrays;

public class C {

	public static void main(String[] args) {
		FastScanner sc=new FastScanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
			int n=sc.nextInt();
			int k=sc.nextInt();
			int arr[]=new int[n];
			int b[]=new int[n];
			int p[]=new int[k+1];
			int temp=0;
			for(int i=0;i<n;i++){
				arr[i]=i+1;
				if(i>=k){
					temp+=2;
					arr[i]-=temp;
				}
			}
//			System.out.println(Arrays.toString(arr));
			int fan=(1+(n-k-1)*2+1)*(n-k)/2;
//			if(n)
			for(int i=1;i<=k;i++){
				p[i]=i;
			}
			for(int i=arr[n-1];i<=(arr[n-1]+k)/2;i++){
				temp=p[i];
				p[i]=p[k-i+arr[n-1]];
				p[k-i+arr[n-1]]=temp;
			}
			for(int i=1;i<=k;i++){
				System.out.print(p[i]+" ");
			}
			System.out.println();
			
//			[1, 2, 3, 4, 3, 2]
//			1,2,3,4,3,2
//			1,2,4,3,4,2
//			1,4,3,2,3,4
			//1, 2, 3, 4, 3, 2, 1//9
//			4,2,3,1,3,2,4
//			4,3,2,1,2,3,4
			
			
		}
	}

	static class FastScanner { 
		private final InputStream is;
		private StringBuilder sB = new StringBuilder(1 << 13);
		private byte[] buf = new byte[1 << 13];
		private int bufLen;
		private int bufOffset;
		private int next;

		public FastScanner(InputStream is) {
			this.is = is;
		}

		private int read() {
			while (bufLen == bufOffset) {
				bufOffset = 0;
				try {
					bufLen = is.read(buf);
				} catch (IOException e) {
					bufLen = -1;
				}
				if (bufLen == -1) {
					return -1;
				}
			}
			return buf[bufOffset++];
		}

		public void skipBlank() {
			while (next >= 0 && next <= 32) {
				next = read();
			}
		}

		public int nextInt() {
			int sign = 1;
			skipBlank();
			if (next == '+' || next == '-') {
				sign = next == '+' ? 1 : -1;
				next = read();
			}
			int val = 0;
			if (sign == 1) {
				while (next >= '0' && next <= '9') {
					val = val * 10 + next - '0';
					next = read();
				}
			} else {
				while (next >= '0' && next <= '9') {
					val = val * 10 - next + '0';
					next = read();
				}
			}
			return val;
		}
		
		public String readString(StringBuilder builder) {
			skipBlank();
			while (next > 32) {
				builder.append((char) next);
				next = read();
			}
			return builder.toString();
		}

		public String next() {
			sB.setLength(0);
			return readString(sB);
		}
	}

	static class FastOutput implements AutoCloseable, Closeable, Appendable {
		private static final int THRESHOLD = 1 << 13;
		private final Writer os;
		private StringBuilder cache = new StringBuilder(THRESHOLD * 2);

		public FastOutput append(CharSequence csq) {
			cache.append(csq);
			return this;
		}

		public FastOutput append(CharSequence csq, int start, int end) {
			cache.append(csq, start, end);
			return this;
		}

		private void afterWrite() {
			if (cache.length() < THRESHOLD) {
				return;
			}
			flush();
		}

		public FastOutput(Writer os) {
			this.os = os;
		}

		public FastOutput(OutputStream os) {
			this(new OutputStreamWriter(os));
		}

		public FastOutput append(char c) {
			cache.append(c);
			afterWrite();
			return this;
		}

		public FastOutput append(int c) {
			cache.append(c);
			afterWrite();
			return this;
		}

		public FastOutput append(String c) {
			cache.append(c);
			afterWrite();
			return this;
		}

		public FastOutput println(String c) {
			return append(c).println();
		}

		public FastOutput println() {
			return append(System.lineSeparator());
		}

		public FastOutput flush() {
			try {
				os.append(cache);
				os.flush();
				cache.setLength(0);
			} catch (IOException e) {
				throw new UncheckedIOException(e);
			}
			return this;
		}

		public void close() {
			flush();
			try {
				os.close();
			} catch (IOException e) {
				throw new UncheckedIOException(e);
			}
		}
		public String toString() {
			return cache.toString();
		}
	}
}