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 CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<int> vi;
/*int vi[10];
int p[15]={0,1,2,3,4,5,6,7,8,9},temp[10];

void init(){
    for(int i=1;i<=10;i++){
        p[i]=i;
    }
}

int mx=0;
int cnt(int s){
    init();

    do{
            int sum=0;
            for(int i=1;i<=9;i++){
                temp[i]=p[vi[i]];
                //printf("%d ",temp[i]);
            }
            //printf("\n");
            for(int i=1;i<=9;i++){
                for(int j=i+1;j<=9;j++){
                    if(temp[i]>temp[j])
                        sum++;
                }
            }
            //printf("%d\n",sum);
            if(sum<=mx){
                for(int i=1;i<=s;i++)
                printf("%d ",p[i]);
                printf("\n");
            }
    }while(next_permutation(p+1,p+s+1));
}

int main(){

    for(int i=5;i<=9;i++){
        printf("%d\n",i);
        for(int j=1;j<=i;j++){
            vi[j]=j;
            printf("%d ",vi[j]);
        }
        for(int j=i+1;j<=9;j++){
            vi[j]=(i*2-j);
            printf("%d ",vi[j]);
        }
        mx=0;
        for(int i=1;i<=9;i++){
                for(int j=i+1;j<=9;j++){
                    if(vi[i]>vi[j])
                        mx++;
                }
            }
        printf("\n");
        cnt(i);
    }
   return 0;
}*/

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n,k;
        scanf("%d%d",&n,&k);
        int change=n-k+1;
        int cnt=k;
        vi.clear();
        for(int i=1;i<=k-change;i++){
            vi.push_back(i);
        }
        for(int i=0;i<change;i++){
            vi.push_back(cnt--);
        }
        for(int i=0;i<vi.size();i++){
            printf("%d ",vi[i]);
        }
        printf("\n");
    }
    return 0;
}