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 javafx.beans.NamedArg;
import java.io.*;
import java.util.Comparator;
import java.util.*;

public class Main {
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        int T = sc.nextInt();
        for(int t = 1; t <= T; ++t){
            solve();
        }
    }
    private static void solve() {
        int n = sc.nextInt();
        int k = sc.nextInt();
        if(k > (n - 1)/2){
            System.out.println(-1);
            return;
        }
        int p_first = 1;
        int p_back = n;
        int[] ans = new int[n];
        int k_copy = k;
        int i;

        for(i = 0; i < k*2; ++i){
            if(i % 2 == 0)
                ans[i] = p_first++;
            else
                ans[i] = p_back--;
        }
        for(;p_first <= p_back; ++p_first){
            ans[i++] = p_first;
        }
        for (int j = 0; j < n; j++) {
            System.out.print(ans[j] + " ");
        }
        System.out.println();
    }


    public static void Codeforces1512D() {
        int len = sc.nextInt() + 2;
        long[] b = new long[len];
        long sum = 0;
        for (int i = 0; i < len; i++) {
            b[i] = sc.nextLong();
            sum += b[i];
        }

        pairs<Integer, Long> max = new pairs(0, 0);//b数组中最大的
        pairs<Integer, Long> secMax = new pairs(0, 0);//b数组中次大的
        for (int i = 0; i < len; i++) {
            if(b[i] > max.value){
                secMax.setValue(max.value);
                secMax.setKey(max.key);
                max.setValue(b[i]);
                max.setKey(i);
            }
            else if(b[i] >= secMax.value){
                secMax.setValue(b[i]);
                secMax.setKey(i);
            }
        }

        int x;
        int other = max.key;
        if(sum - secMax.value - max.value != secMax.value){
            //x不是最大的数， 则asum一定是最大的数，即max
            long aSum = max.value;//a数组的和
            long x_val = sum - 2 * aSum;//x和asum的和
            boolean flag = true;
            if(x_val > aSum){
                System.out.println(-1);
                return;
            }
            for(x = 0; x < len; x++){
                if(b[x] == x_val){
                    flag = false;
                    break;
                }
            }
            if(flag){
                System.out.println(-1);
                return;
            }
        }
        else {
            //x是最大的数
            x = max.key;
            other = secMax.key;
        }
        if(other > x){
            for(int i = 0; i < x; ++i){
                System.out.print(b[i] + " ");
            }
            for(int i = x+1; i < other; ++i){
                System.out.print(b[i] + " ");
            }
            for(int i = other+1; i < len; ++i){
                System.out.print(b[i] + " ");
            }
        }
        else{
            for(int i = 0; i < other; ++i){
                System.out.print(b[i] + " ");
            }
            for(int i = other+1; i < x; ++i){
                System.out.print(b[i] + " ");
            }
            for(int i = x+1; i < len; ++i){
                System.out.print(b[i] + " ");
            }
        }
        System.out.println();
    }
    public static class pairs<K,V> implements Comparable<pairs> {
        private K key;
        public K getKey() { return key; }
        public void setKey(K key) {
            this.key = key;
        }
        private V value;
        public V getValue() { return value; }
        public void setValue(V value) {
            this.value = value;
        }
        public pairs(@NamedArg("key") K key, @NamedArg("value") V value) {
            this.key = key;
            this.value = value;
        }
        @Override
        public String toString() {
            return key + " = " + value;
        }

        @Override
        public int compareTo(pairs o) {
            /*
            if(o.key instanceof Integer && this.key instanceof Integer)
                return Integer.compare((int) this.key, (int) o.key);
            else if(o.key instanceof Long && this.key instanceof Long)
                return Long.compare((long) this.key, (long) o.key);
            else if(o.key instanceof Double && this.key instanceof Double)
                return Double.compare((double) this.key, (double) o.key);
            */
            return 0;
        }
    }
    static class compLongD implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            return Long.compare((long)o2.key, (long)o1.key);
        }
    }
    static class compLongA implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            return Long.compare((long)o1.key, (long)o2.key);
        }
    }
    static class compDoubleD implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            if(o1.key instanceof  Double && o2.key instanceof Double){
                return Double.compare((double) o2.key, (double) o1.key);
            }
            return 0;
        }
    }
    static class compDoubleA implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            if(o1.key instanceof  Double && o2.key instanceof Double){
                return Double.compare((double) o1.key, (double) o2.key);
            }
            return 0;
        }
    }
    static class compIntD implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            if(o1.key instanceof  Integer&&o2.key instanceof  Integer){
                if((int)o1.key>(int)o2.key){
                    return 1;
                }else{
                    return -1;
                }
            }
            return 0;
        }
    }
    static class compIntA implements Comparator<pairs>{
        @Override
        public int compare(pairs o1, pairs o2) {
            if(o1.key instanceof  Integer&&o2.key instanceof  Integer){
                if((int)o1.key>(int)o2.key){
                    return -1;
                }else{
                    return 1;
                }
            }
            return 0;
        }
    }
    public static void solve1(int t) throws Exception {
        int n = sc.nextInt();
        if(n == 0)  return;
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        int ans = 0;
        int lastNum = arr[0];
        int lastFront = arr[0];
        int lastDig = 1;
        while(lastFront >= 10){
            lastFront /= 10;
            lastDig++;
        }
        /*
        System.out.print("Num[0] = " + lastNum);
        System.out.print("  NumDig[0] = " + lastDig);
        System.out.println("  NumFront[0] = " + lastFront);

         */

        for (int i = 1; i < n; ++i){
            int curNum = arr[i];
            boolean goUp = false;
            int curFront = curNum;
            int curDig = 1;
            while(curFront >= 10){
                curFront /= 10;
                curDig++;
            }
            /*
            System.out.print("Num["+i+"] = " + curNum);
            System.out.print("  NumDig["+i+"] = " + curDig);
            System.out.println("  NumFront["+i+"] = " + curFront);

             */
            if(curNum > lastNum){
                lastNum = curNum;
                lastDig = curDig;
                lastFront = curFront;
                continue;
            }
            if(curFront < lastFront || curNum == lastNum)
                goUp = true;
            else if(curFront == lastFront){
                int CUR = curNum;
                int cur_p = curDig-1;
                int LAST = lastNum;
                int last_p = lastDig-1;
                int DIG = 1;
                while(CUR > 0 && LAST > 0){
                    int a = (int) ( CUR / Math.pow(10, cur_p));
                    int b = (int) ( LAST / Math.pow(10, last_p));
                    /*
                    System.out.println("a = " + a);
                    System.out.println("b = " + b);

                     */
                    if(a < b){
                        goUp = true;
                        break;
                    }
                    CUR =  CUR % ((int)Math.pow(10, cur_p+1));
                    LAST = LAST % ((int) Math.pow(10, last_p+1));
                    cur_p--;
                    last_p--;
                    /*
                    System.out.println("CUR = " + CUR);
                    System.out.println("LAST = " + LAST);

                     */
                }

            }
            if(goUp){
                ans += lastDig-curDig+1;
                //System.out.println("ans += " + (lastDig-curDig+1));
                arr[i] *= Math.pow(10, lastDig-curDig+1);
                lastDig += lastDig-curDig;
                lastNum = arr[i];
                lastFront = curFront;
                /*
                System.out.println("UP: Changed to:");
                System.out.print("arr["+i+"] = " + arr[i]);
                System.out.print("  NumDig["+i+"] = " + lastDig);
                System.out.println("  NumFront["+i+"] = " + lastFront);

                 */
            }
            else{
                curNum *= Math.pow(10, lastDig-curDig);
                ans += lastDig - curDig;
                //System.out.println("ans += " + (lastDig - curDig));
                int reminder = (int) (lastNum % Math.pow(10,lastDig-curDig));
                curNum += reminder;
                if(curFront == lastFront)
                    curNum++;

                lastNum = curNum;
                lastFront = curFront;
                /*
                System.out.println("Don't UP: Changed to:");
                System.out.print("Num["+i+"] = " + curNum);
                System.out.print("  NumDig["+i+"] = " + lastDig);
                System.out.println("  NumFront["+i+"] = " + curFront);

                 */
            }
        }
        System.out.println("Case #" + t + ": " + ans);
    }
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(
                    new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                buf[cnt++] = (byte)c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0,
                    BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}