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.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {
	
	// ------------------------------------------------------- Scanner -------------------------------------------------------------------------------------------
	
	public static class Scanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public Scanner() {
	       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;
	    }

	}
	
	// ------------------------------------------------------------ Print and Flush -----------------------------------------------------------------------------------
	
	public static void print(int[] arr) {
		for(int i=0 ; i<arr.length ; i++) System.out.print(arr[i]+" ");
		System.out.println();
	}
	
	public static void print(int[][] arr) {
		for(int i=0 ; i<arr.length ; i++) {
			for(int j=0 ; j<arr[0].length ; j++) System.out.print(arr[i][j]+" ");
			System.out.println();
		}
	}
	
	public static void print(int res) {
		System.out.println(res);
	}
	
	public static void print(String res) {
		System.out.println(res);
	}
	
	public static void print(int a , int b) {
		System.out.println(a + " " + b);
	}
	
	public static void print(char[] res) {
		for (int i = 0 ; i < res.length ; i++) 
			System.out.print(res[i]);
		System.out.println();
	}
	
	public static void flush() {
		System.out.flush();
	}
	
	// ---------------------------------------------------------- Is Palindrome --------------------------------------------------------------------------------------
	
	public static boolean isPalindrome(String str) {
		for (int i = 0 ; i < str.length() ; i++) { 
			if (str.charAt(i) != str.charAt(str.length() - i - 1))
				return false;
		}
		return true;
	}
	
	//----------------------------------------------------- Pair ----------------------------------------------------------------------------------------------------
	
	public static class Pair {
		int x;
		int y;
		Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
		Pair(Pair p) {
			x = p.x;
			y = p.y;
		}
	}
	
	//----------------------------------------------------- Comparator ------------------------------------------------------------------------------------------------
	
	static class cmp implements Comparator<int[]> {
		public int compare(int[] arr1 , int[] arr2) {
			if (arr1[0] > arr2[0])
				return 1;
			return -1;
		}
	}
	
	// ------------------------------------------------------- Tries ------------------------------------------------------------------------------------------------
	
	static class Tries {
		char ch = '\u0000';
		int count = 0;
		Tries[] arr = new Tries[26];
		boolean isEnd = false;
		Tries(char ch) {
			this.ch = ch;
		}
		Tries () { }
	}
	static Tries dummy = new Tries(); 
	static int tries_insert(String str) {
		Tries temp = dummy;
		for (int i = 0 ; i < str.length() ; i++) {
			int pos = str.charAt(i) - 'a';
			if (temp.arr[pos] == null) 
				temp.arr[pos] = new Tries(str.charAt(i));
			temp = temp.arr[pos];
		}
		temp.isEnd = true;
		temp.count += 1;
		return temp.count;
	}
	
	// ------------------------------------------------------ Prime Number (seive) -----------------------------------------------------------------------------------
	
	static int len = 1000001;
	static int[] prime_number = new int[len];
	static Set<Integer> prime_number_set = new HashSet<>();
	static Set<Long> three_factor_set = new HashSet<>(); 
	static void seive() {
		prime_number[0] = 1;
		prime_number[1] = 1;
		for (int i = 2 ; i < len ; i++) {
			if (prime_number[i] == 0) {
				long val = i;
				//prime_number_set.add(i);
				three_factor_set.add(val * val);
				for (int j = i + i ; j < len ; j+=i) 
					prime_number[j] = 1;
			}
		}
	}
	
	
	
	
	// ---------------------------------------------------------- Sqrt ---------------------------------------------------------------------------------------------
		
	
	
	
	// ---------------------------------------------------------- Solve --------------------------------------------------------------------------------------------
	
	public static void solve(Scanner s) {
//		PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
		int n = s.nextInt();
		int k = s.nextInt();
//		int m = s.nextInt();
//		int k1 = s.nextInt();
//		int k2 = s.nextInt();
//		int w = s.nextInt();
//		s.nextLine();
//		String s2 = s.nextLine();
//		int[][] dp = new int[n * m][2];
//		long[] arr = new long[n];
//		for (int i = 0 ; i < n ; i++) 
//			arr[i] = s.nextLong();
//		int[][] data=new int[n][2];
//		String[] arr = new String[n];
//		char[][] data = new char[n][n];
//		for (int i = 0 ; i < n ; i++) 
//			arr[i] = s.nextLine();
//		Pair p1 = new Pair(0 , 0);
//		Pair p2 = new Pair(0 , 0);
//		int count = 0;
//		int a = s.nextInt();
//		int b = s.nextInt();
//		String str = s.nextLine();
//		seive();
		if (k > (n - 1) / 2)
			print(-1);
		else {
			int val = 2;
			System.out.print(1 + " ");
			while (k > 0) {
				System.out.print((val + 1) + " " + val + " ");
				val += 2;
				k -= 1;
			}
			while (val <= n) {
				System.out.print(val + " ");
				val += 1;
			}
			System.out.println();
		}
	}
	public static void main(String[] args) {
		Scanner s = new Scanner();
//	    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	    int t = s.nextInt();
//	    s.nextLine();
	    while(t-->0) 
	    	solve(s);
		
//		e(s);
//	    int n      = s.nextInt();        // read input as integer
//	    long k     = s.nextLong();       // read input as long
//	    double d   = s.nextDouble();     // read input as double
//	    String str = s.next();           // read input as String
//	    String str2  = s.nextLine();       // read whole line as String
//	    long result = 3*k;
//	    out.println(result);                    // print via PrintWriter	   
//	    out.close();
	
	}
}