description: You are given three integers n, a, b. Determine if there exists a permutation p_1, p_2, …, p_n of integers from 1 to n, such that:
  
    * There are exactly a integers i with 2 ≤ i ≤ n-1 such that p_{i-1} < p_i > p_{i+1} (in other words, there are exactly a local maximums).
  
    * There are exactly b integers i with 2 ≤ i ≤ n-1 such that p_{i-1} > p_i < p_{i+1} (in other words, there are exactly b local minimums).
  
  
  
  
  If such permutations exist, find any such permutation.
  
  Input
  
  The first line of the input contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of test cases follows.
  
  The only line of each test case contains three integers n, a and b (2 ≤ n ≤ 10^5, 0 ≤ a,b ≤ n).
  
  The sum of n over all test cases doesn't exceed 10^5.
  
  Output
  
  For each test case, if there is no permutation with the requested properties, output -1.
  
  Otherwise, print the permutation that you are found. If there are several such permutations, you may print any of them.
  
  Example
  
  Input
  
  
  3
  4 1 1
  6 1 2
  6 4 0
  
  
  Output
  
  
  1 3 2 4
  4 2 3 1 5 6
  -1
  
  Note
  
  In the first test case, one example of such permutations is [1, 3, 2, 4]. In it p_1 < p_2 > p_3, and 2 is the only such index, and p_2> p_3 < p_4, and 3 the only such index.
  
  One can show that there is no such permutation for the third test case.
solution: import java.io.OutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.PrintWriter;
  import java.util.*;
  import java.io.IOException;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.io.InputStream;
  
  public class Main {
  
      public static void main(String[] args) {
          InputStream inputStream = System.in;
          OutputStream outputStream = System.out;
          InputReader in = new InputReader(inputStream);
          PrintWriter out = new PrintWriter(outputStream);
          TaskA solver = new TaskA();
          int t;
          t = in.nextInt();
          //t = 1;
          while (t > 0) {
              solver.call(in,out);
              t--;
          }
          out.close();
      }
  
      static class TaskA {
          public void call(InputReader in, PrintWriter out) {
              int n, a, b;
              n = in.nextInt();
              a = in.nextInt();
              b = in.nextInt();
  
              if(a + b > n - 2){
                  out.println(-1);
                  return;
              }
  
              int max = Math.max(a, b);
              if(n%2 == 0){
                  if (max > n / 2 - 1 || Math.abs(a-b) > 1) {
                      out.println(-1);
                      return;
                  }
              }
              else{
                  if (max > n / 2|| Math.abs(a-b) > 1) {
                      out.println(-1);
                      return;
                  }
              }
              if(a+b==0){
                  for (int i = 1; i <=n ; i++) {
                      out.print(i+" ");
                  }
                  out.println();
                  return;
              }
              int i = 1, j = n;
              if(a > b){
                  out.print(1+" ");
                  i++;
                  while(a!=0){
                      out.print(j+" ");
                      j--;
                      if(a==1){
                          break;
                      }
                      out.print(i+" ");
                      i++;
                      a--;
                  }
                  for (int k = j; k >=i; k--) {
                      out.print(k+" ");
                  }
                  out.println();
              }
              else if(a==b) {
                  out.print(1 + " ");
                  i++;
                  while (a != 0) {
                      out.print(j + " ");
                      j--;
  
                      out.print(i + " ");
                      i++;
                      a--;
                  }
                  for (int k = i; k <= j; k++) {
                      out.print(k+" ");
                  }
                  out.println();
              }
              else{
                  out.print(n+" ");
                  j--;
                  while(b!=0){
                      out.print(i+" ");
                      i++;
                      if(b==1){
                          break;
                      }
                      out.print(j+" ");
                      j--;
                      b--;
                  }
                  for (int k = i; k <= j; k++) {
                      out.print(k+" ");
                  }
                  out.println();
              }
  
          }
      }
  
      static int gcd(int a, int b)
      {
          if (a == 0)
              return b;
          return gcd(b % a, a);
      }
  
      static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
  
      static class answer implements Comparable<answer>{
          int a,b;
  
          public answer(int a, int b) {
              this.a = a;
              this.b = b;
          }
  
          @Override
          public int compareTo(answer o) {
              return o.a - this.a;
          }
      }
  
      static class arrayListClass {
          ArrayList<Integer> arrayList2 ;
  
          public arrayListClass(ArrayList<Integer> arrayList) {
              this.arrayList2 = arrayList;
          }
      }
  
      static long gcd(long a, long b)
      {
          if (b == 0)
              return a;
          return gcd(b, a % b);
      }
  
      static void sort(long[] a) {
          ArrayList<Long> l=new ArrayList<>();
          for (long i:a) l.add(i);
          Collections.sort(l);
          for (int i=0; i<a.length; i++) a[i]=l.get(i);
      }
  
      static final Random random=new Random();
  
      static void shuffleSort(int[] a) {
          int n=a.length;
          for (int i=0; i<n; i++) {
              int oi=random.nextInt(n), temp=a[oi];
              a[oi]=a[i]; a[i]=temp;
          }
          Arrays.sort(a);
      }
  
      static class InputReader {
          public BufferedReader reader;
          public StringTokenizer tokenizer;
  
          public InputReader(InputStream stream) {
              reader = new BufferedReader(new InputStreamReader(stream), 32768);
              tokenizer = null;
          }
  
          public String next() {
              while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  try {
                      tokenizer = new StringTokenizer(reader.readLine());
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              }
              return tokenizer.nextToken();
          }
  
          public int nextInt() {
              return Integer.parseInt(next());
          }
          public long nextLong(){
              return Long.parseLong(next());
          }
          public double nextDouble() {
              return Double.parseDouble(next());
          }
  
      }
  }