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.*;

public class Main implements Runnable {

  public static void main(String[] args) {
    new Thread(null, new Main(), "whatever", 1 << 26).start();
  }

  private FastScanner sc;
  private PrintWriter pw;

  public void run() {
    try {
    //   pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    //   sc = new FastScanner(new BufferedReader(new FileReader("input.txt")));
       pw = new PrintWriter(System.out);
       sc = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
    } catch (Exception e) {
      throw new RuntimeException();
    }
    int t = sc.nextInt();
    while (t-- > 0) {
      solve();
    }
    pw.close();
  }



  public void solve() {
    int n = sc.nextInt();
    int k = sc.nextInt();

    if (2 * k >= n || (n < 3 && k > 0)) {
      pw.println("-1");
      return;
    }
    if (k == 0) {
      for (int i = 1; i <= n; i++) {
        pw.print(i + " ");
      }
      pw.println();
      return;
    }

    int[] arr = new int[n];

    for (int i = n, j = 0, b = 0, p = 1; b < n; b++) {
      // pw.println("Inside");
      if (b % 2 == 1 && (j) != k) {
        j++;
        arr[b] = i;
        i--;
      } else {
        arr[b] = p;
        p++;
      }
    }

    for (int i = 0; i < n; i++) {
      pw.print(arr[i] + " ");
    }

    pw.println();
  }



  class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;

    public FastScanner(BufferedReader bf) {
      reader = bf;
      tokenizer = null;
    }

    public String next() {
      if (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine());
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }

    public String nextLine() {
      if (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          return reader.readLine();
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }

    public long nextLong() {
      return Long.parseLong(next());
    }

    public int nextInt() {
      return Integer.parseInt(next());
    }

    public double nextDouble() {
      return Double.parseDouble(next());
    }

    public float nextFloat() {
      return Float.parseFloat(next());
    }

    public int[] nextIntArray(int n) {
      int[] a = new int[n];
      for (int i = 0; i < n; i++) {
        a[i] = nextInt();
      }
      return a;
    }

    public String[] nextStringArray(int n) {
      String[] a = new String[n];
      for (int i = 0; i < n; i++) {
        a[i] = next();
      }
      return a;
    }

    public long[] nextLongArray(int n) {
      long[] a = new long[n];
      for (int i = 0; i < n; i++) {
        a[i] = nextLong();
      }
      return a;
    }

  }

}