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.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;

import javafx.util.Pair;

import static java.lang.Math.pow;
import static java.lang.Math.abs;
import static java.lang.Math.ceil;

public class Main {
	
	static void pr(int odd) {
		System.out.println(odd);
	}

	static void pr(long[] ar) {
		for (long i : ar) {
			System.out.print(i + " ");
		}
		System.out.println("");
	}
	
	static void pr(int[] ar) {
		for (int i : ar) {
			System.out.print(i + " ");
		}
		System.out.println("");
	}
	
	static void pr(boolean[] ar) {
		for (boolean i : ar) {
			System.out.print(i + " ");
		}
		System.out.println("");
	}
	
	int min(long[] ar, int n) {
		int min = 0;
		for (int i = 0; i < ar.length; i++) {
			min = ar[min] > ar[i] ? i : min;
		}
		return min;
	}
	
	int max(int[] ar) {
		int max = 0;
		for (int i = 0; i < ar.length; i++) {
			max = ar[i] > ar[max] ? i : max;
		}
		return max;
	}

	int max(long[] ar) {
		int max = 0;
		for (int i = 0; i < ar.length; i++) {
			max = ar[i] > ar[max] ? i : max;
		}
		return max;
	}

	int max(List<Integer> ar) {
		int max = 0;
		for (int i = 0; i < ar.size(); i++) {
			max = ar.get(i) > ar.get(max) ? i : max;
		}
		return max;
	}

	int kgv(int a, int b) {
		int ret = 0;
		outer: for (int i = 1; i <= b; i++) {
			for (int j = 1; j <= a; j++) {
				if (b * j > a * i)
					break;
				if (b * j == a * i) {
					ret = a * i;
					break outer;
				}
			}
		}
		return ret;
	}

	int binarySearch(List<Integer> ar, int x, int l, int r) {
		if (l <= r) {
			int mid = l + (r - l) / 2;

			if (ar.get(mid) == x)
				return mid;

			if (ar.get(mid) > x)
				return binarySearch(ar, x, l, mid - 1);
			else
				return binarySearch(ar, x, mid + 1, r);
		}

		return -1;
	}
	
	long choose(double n, double k) {
		double ret = 1;
		for(int i = 0; i < k; i++) {
			ret *= (n - i) / (k - i);
		}
		return (long) ret;
	}
	
	int binarySearch(int[] ar, int x, int l, int r) {
		if (l <= r) {
			int mid = l + (r - l) / 2;

			if (ar[mid] == x)
				return mid;

			if (ar[mid] > x)
				return binarySearch(ar, x, l, mid - 1);
			else
				return binarySearch(ar, x, mid + 1, r);
		}

		return -1;
	}
	
	static int n, m, k; 
	static int r, x, y;
	static long a, b, c, d, q, h, w;
	static long[] ar;
	static long[][] grid;
	static String s, s1, s2;
	
	static final int mod = (int) pow(10, 9) + 7;
	static final int intm = Integer.MAX_VALUE;
	static final long longm = Long.MAX_VALUE;
	
	static HashMap<Integer, ArrayList<Pair<Integer, Boolean>>> adjlist = new HashMap<>();
	static int root;
	
	
	void testCase() {
		if((n-1)/2 < k) {
			System.out.println(-1);
			return;
		}
		
		int[] ar = new int[n];
		for(int i = 1; i <= n; i++) {
			ar[i-1] = i;
		}
		
		for(int i = 1; i < n; i+=2) {
			if(k != 0) {
				int a = ar[i];
				ar[i] = ar[i+1];
				ar[i+1] = a;
				k--;
			}
		}
		
		pr(ar);
		
	}

	//C
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Main main = new Main();
		//StringBuilder sb = new StringBuilder();
		
		int t = sc.nextInt();
		for(int round = 0; round < t; round++) {
			n = sc.nextInt();
			k = sc.nextInt();
			main.testCase();
		}
		sc.close();
		
	}
}