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.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.util.*;
  import java.util.stream.Stream;
  
  public class Program {
  
      static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
      static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
  
      public static void main(String[] args) throws NumberFormatException, IOException {
  
          int cases = Integer.parseInt(reader.readLine());
          int mod = 998244353;
  
          while(cases-- > 0) {
  
              String[] firstLine = reader.readLine().split(" ");
              int n = Integer.parseInt(firstLine[0]);
              int a = Integer.parseInt(firstLine[1]);
              int b = Integer.parseInt(firstLine[2]);
  
              if(Math.abs(a-b) > 1 || a+b > n-2 ) {
                  printNumber(-1);
                  continue;
              }
              List<Integer> list = new ArrayList<>();
  
              if(a==b) {
                  int k = a;
                  list.add(1);
                  int ele = 3;
                  while(k-->0) {
                      list.add(ele);
                      list.add(ele-1);
                      ele+=2;
                  }
                  int end = 2;
                  if(list.size() >= 2) {
                      end = list.get(list.size()-2);
                      end++;
                  }
                  while(end<=n) {
                      list.add(end);
                      end++;
                  }
              }else if(a>b) {
                  int k = a-1;
                  int ele = 3;
                  list.add(1);
                  while(k-->0) {
                      list.add(ele);
                      list.add(ele-1);
                      ele+=2;
                  }
                  int start = n;
                  int end = 1;
                  if(list.size() >= 2) {
                      end = list.get(list.size()-2);
                  }
  
                  while(start>end) {
                      list.add(start);
                      start--;
                  }
              }else {
                  int k = b;
                  int ele = 2;
                  while(k-->0) {
                      list.add(ele);
                      list.add(ele-1);
                      ele+=2;
                  }
                  int end = list.get(list.size()-2);
                  end++;
                  while(end<=n) {
                      list.add(end);
                      end++;
                  }
              }
  
             for(int i: list) {
                 out.append(i + " ");
             }
              out.append("\n");
  
          }
  
          out.flush();
  
      }
  
      public static int[] convertToIntPrimitiveArray(String[] str) {
          return Stream.of(str).mapToInt(Integer::parseInt).toArray();
      }
  
      public static Integer[] convertToIntArray(String[] str) {
          Integer[] arr = new Integer[str.length];
          for(int i=0;i<str.length;i++) {
              arr[i] = Integer.parseInt(str[i]);
          }
          return arr;
      }
  
      public static Long[] convertToLongArray(String[] str) {
          Long[] arr = new Long[str.length];
          for(int i=0;i<str.length;i++) {
              arr[i] = Long.parseLong(str[i]);
          }
          return arr;
      }
  
      public static long[] convertToLongPrimitiveArray(String[] str) {
          return Stream.of(str).mapToLong(Long::parseLong).toArray();
      }
  
      public static void printYes() throws IOException {
          out.append("YES" + "\n");
      }
  
      public static void printNo() throws IOException {
          out.append("NO" + "\n");
      }
  
      public static void printNumber(long num) throws IOException {
          out.append(num + "\n");
      }
  
      public static long hcf(long a, long b) {
          if(b==0) return a;
          return hcf(b, a%b);
      }
  
      public static int findSet(int[] parent, int[] rank, int v) {
          if(v==parent[v]) {
              return v;
          }
          parent[v] = findSet(parent, rank, parent[v]);
          return parent[v];
      }
  
      public static void unionSet(int[] parent, int[] rank, int a, int b) {
  
          a = findSet(parent, rank, a);
          b = findSet(parent, rank, b);
  
          if(a == b) {
              return;
          }
  
          if(rank[a] < rank[b]) {
              int temp = a;
              a = b;
              b = temp;
          }
  
          parent[b] = a;
          if(rank[a] == rank[b]) {
              rank[a]++;
          }
  
      }
  
      public static void makeSet(int[] parent, int[] rank, int v) {
          parent[v] = v;
          rank[v] = 0;
      }
  
      public static long modularDivision(long a, long b, int mod) {
          if(a==0) return 1;
          a %= mod;
          long res = 1L;
          while(b > 0) {
              if((b&1)==1) {
                  res = (res * a)%mod;
              }
              a = (a*a)%mod;
              b >>= 1;
          }
          return res;
      }
  
      public static void customSort(int[] arr) {
          int n = arr.length;
          Random rnd = new Random();
          for(int i=0; i<n; ++i){
              int tmp = arr[i];
              int randomPos = i + rnd.nextInt(n-i);
              arr[i] = arr[randomPos];
              arr[randomPos] = tmp;
          }
          Arrays.sort(arr);
          return;
      }
  
      public static long[] factorial(int n, int mod) {
          long[] fact = new long[n+1];
          fact[0] = 1;
          for(int i=1;i<fact.length;i++) {
              fact[i] = (i*fact[i-1] + mod)%mod;
          }
          return fact;
      }
  
  }