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

Solution:
import java.util.*;
import java.io.*;
import java.math.*;

public class Test
{   static StringBuilder out;
    
    static void solve() throws IOException{
       int n = fs.nextInt();
       int k = fs.nextInt();
       int[]arr = new int[n];
       for(int i=1;i<=n;i++) arr[i-1] = i;
       int j = 1;
       while(k > 0 && j < n && j+1 < n){
            swap(arr, j, j+1);
            k--;
            j += 2;
       }
       if(k > 0){
           pw.println(-1);
           return;
       }
       for(int x : arr){
           pw.print(x+" ");
       }
       pw.println();
    }
 
    public static void main (String[] args) throws java.lang.Exception
    {
        fs = new FastReader();
        out = new StringBuilder();
        int t = fs.nextInt(); 
        while (t-- > 0) 
        { 	
            solve();
        }
        pw.flush();
        pw.close();
    }
    //-------------------------------------------------
    static long[] arrayInput(int n) throws IOException{
        long[] arr = new long[n];
        for(int i=0;i<n;i++) arr[i] = fs.nextLong();
        return arr;
    }
    static void swap(int[]arr, int a, int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    static void ruffleSort(long arr[]){
        for(int i = 0; i<arr.length; i++){ 
            int t = (int) Math.random() * arr.length; 
            long x = arr[t]; 
            arr[t] = arr[i]; 
            arr[i] = x; 
        }
        Arrays.sort(arr);
    } 
    static boolean isPrimeProbable(BigInteger bi){
        return bi.isProbablePrime(10);
    }
    static BigInteger nextProbablePrime(BigInteger bi){
        return bi.nextProbablePrime();
    }
    static final int MOD = (int) 1e9+7;
    static final int INT_MAX = Integer.MAX_VALUE;
    static final int INT_MIN = Integer.MIN_VALUE;
    static FastReader fs;
    static PrintWriter pw = new PrintWriter(System.out);

    //--------Reader section-----------------
    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;}
    }
}