/*
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
ordered_set -> less -> less_equal
ordered_set find_by_order(k) -> k element
ordered_set order_of_key(k) -> returns the number of elements in a set strictly smaller than k
*/
#include <bits/stdc++.h>
#include <random>
//#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
//using namespace __gnu_pbds;

//template<typename T> using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

const long long maxn = 3e5 + 123;
const long long inf = 1e9 + 123;
const long long linf = 1e18 + 123;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
int dx[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int dy[8] = {1, 0, 0, -1, 1, 1, -1, -1};

int ans[maxn];

int main(){
    #ifndef ONLINE_JUDGE
        freopen("input.cpp", "r", stdin);
        freopen("output.cpp", "w", stdout);
    #endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int T;
    cin >> T;
    while (T --){
        int n, k;
        cin >> n >> k;
        int cntr = 1, kol = 0;
        int last = k;
        for (int i = k + 1; i <= n; i++){
            kol += cntr;
            last--;
            cntr++;
        }
        cntr = k - 2;
        int kol1 = k - 1;
        for (int i = k + 1; i <= n; i++){
            kol1 += cntr * 2;
            cntr--;
        }
        int mx = kol - kol1;
        last--;
        for (int i = 1; i <= last; i++){
            ans[i] = i;
        }
        int cur = k;
        for (int i = last + 1; i <= k; i++){
            ans[i] = cur;
            cur--;
        }
        for (int i = 1; i <= k; i++){
            cout << ans[i] << " ";
        }
        cout << "\n";
    }
    exit(0);
}

### Prompt

In Cpp, your task is to solve the following 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.

### Response

```cpp
/*
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
ordered_set -> less -> less_equal
ordered_set find_by_order(k) -> k element
ordered_set order_of_key(k) -> returns the number of elements in a set strictly smaller than k
*/
#include <bits/stdc++.h>
#include <random>
//#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
//using namespace __gnu_pbds;

//template<typename T> using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

const long long maxn = 3e5 + 123;
const long long inf = 1e9 + 123;
const long long linf = 1e18 + 123;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
int dx[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int dy[8] = {1, 0, 0, -1, 1, 1, -1, -1};

int ans[maxn];

int main(){
    #ifndef ONLINE_JUDGE
        freopen("input.cpp", "r", stdin);
        freopen("output.cpp", "w", stdout);
    #endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int T;
    cin >> T;
    while (T --){
        int n, k;
        cin >> n >> k;
        int cntr = 1, kol = 0;
        int last = k;
        for (int i = k + 1; i <= n; i++){
            kol += cntr;
            last--;
            cntr++;
        }
        cntr = k - 2;
        int kol1 = k - 1;
        for (int i = k + 1; i <= n; i++){
            kol1 += cntr * 2;
            cntr--;
        }
        int mx = kol - kol1;
        last--;
        for (int i = 1; i <= last; i++){
            ans[i] = i;
        }
        int cur = k;
        for (int i = last + 1; i <= k; i++){
            ans[i] = cur;
            cur--;
        }
        for (int i = 1; i <= k; i++){
            cout << ans[i] << " ";
        }
        cout << "\n";
    }
    exit(0);
}

```