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:
// optimization flags
#pragma GCC target ("avx2")
// TODO: safe?
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
// including std
#include <bits/stdc++.h>
using namespace std;
// use solve instead of main for easy fast input
void solve(); void subcases(); void precompute();
int32_t main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout<<setprecision(17); subcases(); }
// generic printing of iterators
template<typename T_container,typename T = typename enable_if<!is_same<T_container,string>::value, typename T_container::value_type>::type>
ostream& operator<<(ostream& os,const T_container& v){ os << '{'; string sep; for (const T& x: v) os<< sep << x, sep = ", "; return os << '}'; }
// python-ish read and print functions
template<typename T> T read(){ T x; cin >> x; return x; }
template<typename T> void read(T& x) { cin >> x; }
template<typename T> void print(const T& x) { cout << x<< "\n"; }
// macro/template hackery to get quick debug info
template<typename L> void DEBUG_(const char* str, L& last) { cout << str << " = " << last << endl; }
template<typename H, typename ...T> void DEBUG_(const char* str, H& val, T&... tail) {
	const char* comma = strchr(str, ',');
	cout << regex_replace(string(str, comma), regex("^ +| +$|( ) +"), "$1") << " = " << val << ", ";
	DEBUG_(comma+1, tail...);
}
// f should be monotone increasing mapping integers to booleans,
// i.e. falses and then trues (outputs whether input is 'at least' good)
// returns the first true value of f in [lo, hi) or else hi
template<class F>
int bsearch(int lo, int hi, F f) {
	while (hi > lo) {
		int mid = (lo + hi) / 2;
		if (f(mid)) hi = mid;
		else lo = mid + 1;
	}
	return lo;
}
#define DEBUG(...) DEBUG_(#__VA_ARGS__, __VA_ARGS__)
// macro hackery to generate new names
#define CONCAT_(x,y) x##y
#define CONCAT(x,y) CONCAT_(x,y)
#define FRESHVAR() CONCAT(__FRESHVAR__, __COUNTER__)
// use 64-bit integers by default (make sure to actually submit in 64 bit)
#define int int_fast64_t
#define db double
// iterator utility defines
#define AR array
#define IT(x) begin(x), end(x)
#define sz size
// loop utility defines
#define TIMES_(i,n) for (int i = (n); i > 0; i--)
#define TIMES(n) TIMES_(FRESHVAR(), n)
#define FOR(i,n) for (int i = 0; i < (n); i++)
#define FORS(i,s,n) for (int i = (s); i < (n); i++)
#define FOR1(i,n) for (int i = 1; i <= (n); i++)
#define FORR(i,n) for (int i = (n) - 1; i >= 0; i--)
#define FORBIT(idx,v,m) for (int idx = 0, v = 1; idx < (m); idx++, v <<= 1)
// common function defines
#define caseout(x) do { print(x); return; } while (0)
#define pb push_back
#define vi vector<int>
#define mp make_pair
#define ri read<int>

const string NOYES[2] = {"NO","YES"};
const string NoYes[2] = {"No","Yes"};
const int INF = numeric_limits<int>::max() / 10;

// UTILITY PASTE

// END UTIL

void subcases() {
	precompute();
	TIMES(ri()) solve();
}

void precompute() {

}

const int maxN = 100005;
int n, k, a[maxN];

void solve() {
	cin >> n >> k;
	int d = n - k;
	FOR1(i, k - d - 1) cout << i << " ";
	for (int i = k; i >= k - d; i--) cout << i << " ";
	cout << "\n";
}