Problem: A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.

Input

The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.

Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.

Output

Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks. 

If there are multiple answers, print any.

Example

Input


5
1 0
5 2
6 6
2 1
6 1


Output


1 
2 4 1 5 3 
-1
-1
1 3 6 5 4 2

Note

In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). 

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long double ld;
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define ll long long
#define pb push_back
#define mk make_pair
#define MOD 1000000007
#define pii pair<int,int>
#define gcd(a,b) __gcd((a),(b))
#define endl "\n"
#define UB upper_bound
#define LB lower_bound
#define BS binary_search
#define PI 3.1415926535897932384626433832795
#define dec(x) fixed<<setprecision(x)
#define lcm(a,b) (a*b/__gcd(a,b))
#define fi(i,n) for(int i=0;i<n;i++)
#define f(i, a, b) for(int i=a;i<b;i++)


// ll d, x, y;
// void extendedEuclid(ll A, ll B)
// {
//     if(B == 0)
//     {
//         d = A;
//         x = 1;
//         y = 0;
//     }
//     else
//     {
//         extendedEuclid(B, A%B);
//         int temp = x;
//         x = y;
//         y = temp - (A/B)*y;
//     }
// }
// ll digits(ll n)
// {
//     return floor(log10(double(n))) + 1;
// }

// ll modularExponentiation(ll x,ll n,ll M)
// {
//     ll result = 1;
//     while(n>0)
//     {
//         if(n % 2 ==1)
//         {
//             result = ((result%M)*(x%M))%M;
//         }
//         x  = ((x%M)*(x%M))%M;
//         n = n/2;
//     }
//     return result%M;
// }

// // DP solution for nCr
// ll nCrModp(ll n, ll r)
// {
//     if (r > n - r)
//         r = n - r;
//     ll C[r + 1];
//     memset(C, 0, sizeof(C));

//     C[0] = 1;
//     for (ll i = 1; i <= n; i++)
//     {
//         for (ll j = min(i,r); j > 0; j--)
//         {
//             C[j] = (C[j] + C[j - 1]);
//         }

//     }
//     return C[r];
// }
// ll modInverse(ll A, ll M)
// {
//     extendedEuclid(A,M);
//     return (x%M+M)%M;    //x may be negative
// }
// // primefactors[a] = primefactors[a/primedivisor[a]] + 1


ll sumdigits(ll n)
{
    ll ans = 0;
    while(n>0)
    {
        ans += n%10;
        n = n/10;
    }
    return ans;
}


// ll less_power2(ll n)
// {
//     ll i = 1;
//     while(i*2<=n)
//     {
//         i = i*2;
//     }
//     return i;
// }
// bool isPrime(int n)
// {
//     // Corner cases
//     if (n <= 1)
//         return false;
//     if (n <= 3)
//         return true;
//     if (n % 2 == 0 || n % 3 == 0)
//         return false;

//     for (int i = 5; i * i <= n; i = i + 6)
//         if (n % i == 0 || n % (i + 2) == 0)
//             return false;
//     return true;
// }
// vector<int>adj[101];
// int visited[100];
// void dfs(string ans,int v,int d)
// {
//     ans += v + '0';
//     if(v==d)
//     {
//         cout<<ans<<endl;
//         return;
//     }
//     visited[v] = 1;
//     for(auto x : adj[v])
//     {
//         if(visited[x]==0)
//         {
//             dfs(ans,x,d);
//         }
//     }
//     visited[v] = 0;
// }


// ll totaldivisor(ll n)
// {
// 	ll total=1;
// 	ll cnt=0;
// 	while(n%2==0)
// 	{
// 		n/=2;
// 		cnt++;
// 	}
// 	total=total*(cnt+1);
// 	for(ll i=3;i<=n;i+=2)
// 	{
// 		if(n%i==0)
// 		{
// 			cnt=0;
// 			while(n%i==0)
// 			{
// 				n/=i;
// 				cnt++;
// 			}
// 			total=total*(cnt+1);
// 		}
// 	}
// 	return total;
// }
// string longDivision(string number, int divisor) 
// { 
//     // As result can be very large store it in string 
//     string ans; 
  
//     // Find prefix of number that is larger 
//     // than divisor. 
//     int idx = 0; 
//     int temp = number[idx] - '0'; 
//     while (temp < divisor) 
//         temp = temp * 10 + (number[++idx] - '0'); 
  
//     // Repeatedly divide divisor with temp. After 
//     // every division, update temp to include one 
//     // more digit. 
//     while (number.size() > idx) { 
//         // Store result in answer i.e. temp / divisor 
//         ans += (temp / divisor) + '0'; 
  
//         // Take next digit of number 
//         temp = (temp % divisor) * 10 + number[++idx] - '0'; 
//     } 
  
//     // If divisor is greater than number 
//     if (ans.length() == 0) 
//         return "0"; 
  
//     // else return ans 
//     return ans; 
// } 




// bool isSubsetSum(vector<ll>set, ll n, ll sum)
// {
//     // The value of subset[i][j] will be true if
//     // there is a subset of set[0..j-1] with sum
//     // equal to i
//     bool subset[n + 1][sum + 1];
 
//     // If sum is 0, then answer is true
//     for (int i = 0; i <= n; i++)
//         subset[i][0] = true;
 
//     // If sum is not 0 and set is empty,
//     // then answer is false
//     for (int i = 1; i <= sum; i++)
//         subset[0][i] = false;
 
//     // Fill the subset table in botton up manner
//     for (int i = 1; i <= n; i++) {
//         for (int j = 1; j <= sum; j++) {
//             if (j < set[i - 1])
//                 subset[i][j] = subset[i - 1][j];
//             if (j >= set[i - 1])
//                 subset[i][j] = subset[i - 1][j]
//                               || subset[i - 1][j - set[i - 1]];
//         }
//     }
 
//     /*   // uncomment this code to print table
//      for (int i = 0; i <= n; i++)
//      {
//       for (int j = 0; j <= sum; j++)
//           printf ("%4d", subset[i][j]);
//       printf("\n");
//      }*/
 
//     return subset[n][sum];
// }


/*---------------------------------------------------
unsigned long long power(unsigned long long x, 
                                  int y, int p)
{
    unsigned long long res = 1; // Initialize result
 
    x = x % p; // Update x if it is more than or
    // equal to p
 
    while (y > 0) 
    {
     
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res * x) % p;
 
        // y must be even now
        y = y >> 1; // y = y/2
        x = (x * x) % p;
    }
    return res;
}
 
// Returns n^(-1) mod p
unsigned long long modInverse(unsigned long long n,  
                                            int p)
{
    return power(n, p - 2, p);
}
 
// Returns nCr % p using Fermat's little
// theorem.
unsigned long long nCrModPFermat(unsigned long long n,
                                 int r, int p)
{
    // If n<r, then nCr should return 0
    if (n < r)
        return 0;
    // Base case
    if (r == 0)
        return 1;
 
    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r
    unsigned long long fac[n + 1];
    fac[0] = 1;
    for (int i = 1; i <= n; i++)
        fac[i] = (fac[i - 1] * i) % p;
 
    return (fac[n] * modInverse(fac[r], p) % p
            * modInverse(fac[n - r], p) % p)
           % p;
}
  */
//  int lis(vector<int> const& a) {
//     int n = a.size();
//     const int INF = 1e9;
//     vector<int> d(n+1, INF);
//     d[0] = -INF;

//     for (int i = 0; i < n; i++) {
//         int j = upper_bound(d.begin(), d.end(), a[i]) - d.begin();
//         if (d[j-1] <= a[i] && a[i] <= d[j])
//             d[j] = a[i];
//     }

//     int ans = 0;
//     for (int i = 0; i <= n; i++) {
//         if (d[i] < INF)
//             ans = i;
//     }
//     return ans;
// }

// ll power(ll x, ll y)
// {
//     ll temp;
//     if( y == 0)
//         return 1;
//     temp = power(x, y/2);
//     if (y%2 == 0)
//         return (ll)(temp*temp);
//     else
//         return (ll)(x*temp*temp);
// }

//Quick select
// int partition(int a[],int pivot,int lo,int hi){
//     cout<<"Pivot->"<<pivot<<endl;
//     int i=lo, j=lo;
//     while(i<=hi){
//         if(a[i]<=pivot){
//             swap(a[i],a[j]);
//             i++;
//             j++;
//         }
//         else{
//             i++;
//         }
//     }
//     cout<<"pivot index"<<(j-1)<<endl;
//     return (j-1);
// }
// int quickselect(int a[],int lo,int hi, int k){
//     int pivot=a[hi];
//     int pi=partition(a,pivot,lo,hi);
//     if(k>pi){
//         return quickselect(a,pi+1,hi,k);
//     }
//     else if(k<pi){
//         return quickselect(a,lo,pi-1, k);
//     }
//     else{
//         return a[k];
//     }
// }


//int freq[1000007];
// void primeFactors(int n)  
// {  
//     freq[n]=1;
//     while (n % 2 == 0)  
//     {  
//         mp[2]++;
//         n/=2;
//     }
//     for (int i = 3; i <= sqrt(n); i = i + 2)  
//     { 
//         while (n % i == 0)  
//         {  
//             mp[i]++;
//             n/=i;
//         }  
//     }  
  
//     if (n > 2) mp[n]++;
    
//   // return (int)mp.size();
// }  



int main() {

/*#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);

#endif*/
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    int t;
    cin >> t;
    while(t--){
        int n, k;
        cin >> n >> k;
        int peak = n /2 + (n % 2) - 1;
        if(k > peak){
            cout << - 1<< endl;
        }
        else{
            cout << 1 <<" ";
            peak = min(peak, k);
                    int a = 2, b = 3;
                    while(peak -- > 0){
                        cout << b <<" " << a << " ";
                        a += 2; b+= 2;
                    }
                    for(int i = a; i <= n; i++){
                        cout << i <<" "; 
                    }
                cout << endl;
            
        }
    }
    return 0;
}