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.util.*;
import java.lang.*;
import java.io.*;
 
public class Main {
	static class FastReader {
		BufferedReader br;
		StringTokenizer st;
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	} 
	static int gcd(int a, int b) 
	{ 
		if (a == 0) 
			return b; 
		return gcd(b % a, a); 
	}
	static class mysort implements Comparable<mysort>
	{
		int height;
		int width;
		int index;
		
		mysort(int height,int width,int index){
			this.height=height;
			this.width=width;
			this.index=index;
		}

		public int compareTo(mysort ms){
			if(this.height>ms.height){
				return 1;
			}
			else if(this.height<ms.height){
				return -1;
			}
			else{
				return this.width-ms.width;
			}
		}
	}
	static class mysort2 implements Comparable<mysort2>
	{
		int index;
		int ans;
		
		mysort2(int index,int ans){
			this.index=index;
			this.ans=ans;
		}

		public int compareTo(mysort2 ms){

				return this.index-ms.index;
			
		}
	}	
	static int binary_search(int start,int end,int n,ArrayList<mysort> abc,int val){
		int mid=(start+end)/2;
		if(abc.get(mid).height<val &&(mid+1<n)&&abc.get(mid+1).height>=val){
			return mid;
		}
		else if(abc.get(mid).height<val && (mid+1<n)){
			return binary_search(mid+1,end,n,abc,val);
		}
		else if(abc.get(mid).height>=val && (mid-1)>=0){
			return binary_search(start,mid-1,n,abc,val);
		}
		return -1;
	}

     
    // method to return LCM of two numbers
    static int lcm(int a, int b)
    {
        return (a / gcd(a, b)) * b;
    }	

public static void main(String args[]) throws Exception
{
	 // try {
	 //  FileOutputStream output=new FileOutputStream("C:\\Users\\vishr\\OneDrive\\Desktop\\java\\output.txt");
	 //  PrintStream out=new PrintStream(output);
	 //  //Diverting the output stream into file "temp.out".Comment the below line to use console
	 //  System.setOut(out);
	  
	 //  InputStream input=new FileInputStream("C:\\Users\\vishr\\OneDrive\\Desktop\\java\\input.txt");
	 //  //Diverting the input stream into file "temp.in".Comment the below line to use console
	 //  System.setIn(input);
	  
	 // } catch (FileNotFoundException e) {
	 //  e.printStackTrace();
	 // }

  FastReader sc = new FastReader();
  int t=sc.nextInt();
  for(int test=0;test<t;test++){
  	int n=sc.nextInt();
  	int k=sc.nextInt();
  	int index=2*k-n-1;
  	int c1=0,c2=1;

  	while(c1!=index && c1!=k){
  		System.out.print(c2+" ");
  		++c1;
  		++c2;
  	}
  	c2=k;
  	while(c1!=k){
  		System.out.print(c2+" ");
  		--c2;
  		++c1;
  	}
  	System.out.println("");

  }
}
 
} 
//1 2 3 2 1