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.util.*;
  import java.lang.*;
  import java.io.*;
  
  public class Main {
      static FastReader in;
      static PrintWriter out;
  
      static int bit(long n) {
          return (n == 0) ? 0 : (1 + bit(n & (n - 1)));
      }
  
      static void p(Object o) {
          out.print(o);
      }
  
      static void pn(Object o) {
          out.println(o);
      }
  
      static void pni(Object o) {
          out.println(o);
          out.flush();
      }
  
      static String n() throws Exception {
          return in.next();
      }
  
      static String nln() throws Exception {
          return in.nextLine();
      }
  
      static int ni() throws Exception {
          return Integer.parseInt(in.next());
      }
  
      static long nl() throws Exception {
          return Long.parseLong(in.next());
      }
  
      static double nd() throws Exception {
          return Double.parseDouble(in.next());
      }
  
      static class FastReader {
          static BufferedReader br;
          static StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          public FastReader(String s) throws Exception {
              br = new BufferedReader(new FileReader(s));
          }
  
          String next() throws Exception {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      throw new Exception(e.toString());
                  }
              }
              return st.nextToken();
          }
  
          String nextLine() throws Exception {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  throw new Exception(e.toString());
              }
              return str;
          }
      }
  
      static long power(long a, long b) {
          if (b == 0)
              return 1;
          long val = power(a, b / 2);
          val = val * val;
          if ((b % 2) != 0)
              val = val * a;
          return val;
      }
  
      static long power(long a, long b, long mod) {
          if (b == 0)
              return 1L;
          long val = power(a, b / 2) % mod;
          val = (val * val) % mod;
          if ((b % 2) != 0)
              val = (val * a) % mod;
          return val % mod;
      }
  
      static ArrayList<Long> prime_factors(long n) {
          ArrayList<Long> ans = new ArrayList<Long>();
          while (n % 2 == 0) {
              ans.add(2L);
              n /= 2L;
          }
          for (long i = 3; i <= Math.sqrt(n); i++) {
              while (n % i == 0) {
                  ans.add(i);
                  n /= i;
              }
          }
          if (n > 2) {
              ans.add(n);
          }
          return ans;
      }
  
      static void sort(ArrayList<Long> a) {
          Collections.sort(a);
      }
  
      static void reverse_sort(ArrayList<Long> a) {
          Collections.sort(a, Collections.reverseOrder());
      }
  
      static void swap(long[] a, int i, int j) {
          long temp = a[i];
          a[i] = a[j];
          a[j] = temp;
      }
  
      static void swap(List<Long> a, int i, int j) {
          long temp = a.get(i);
          a.set(j, a.get(i));
          a.set(j, temp);
      }
  
      static void sieve(boolean[] prime) {
          int n = prime.length - 1;
          Arrays.fill(prime, true);
          for (int i = 2; i * i <= n; i++) {
              if (prime[i]) {
                  for (int j = 2 * i; j <= n; j += i) {
                      prime[j] = false;
                  }
              }
          }
      }
  
      static long gcd(long a, long b) {
          if (b == 0)
              return a;
          return gcd(b, a % b);
      }
  
      static long mod = 1000000007;
  
      public static void sort(long[] arr, int l, int r) {
          if (l >= r)
              return;
          int mid = (l + r) / 2;
          sort(arr, l, mid);
          sort(arr, mid + 1, r);
          merge(arr, l, mid, r);
      }
  
      public static void sort(int[] arr, int l, int r) {
          if (l >= r)
              return;
          int mid = (l + r) / 2;
          sort(arr, l, mid);
          sort(arr, mid + 1, r);
          merge(arr, l, mid, r);
      }
  
      static void merge(int[] arr, int l, int mid, int r) {
          int[] left = new int[mid - l + 1];
          int[] right = new int[r - mid];
          for (int i = l; i <= mid; i++) {
              left[i - l] = arr[i];
          }
          for (int i = mid + 1; i <= r; i++) {
              right[i - (mid + 1)] = arr[i];
          }
          int left_start = 0;
          int right_start = 0;
          int left_length = mid - l + 1;
          int right_length = r - mid;
          int temp = l;
          while (left_start < left_length && right_start < right_length) {
              if (left[left_start] < right[right_start]) {
                  arr[temp] = left[left_start++];
              } else {
                  arr[temp] = right[right_start++];
              }
              temp++;
          }
          while (left_start < left_length) {
              arr[temp++] = left[left_start++];
          }
          while (right_start < right_length) {
              arr[temp++] = right[right_start++];
          }
      }
  
      static void merge(long[] arr, int l, int mid, int r) {
          long[] left = new long[mid - l + 1];
          long[] right = new long[r - mid];
          for (int i = l; i <= mid; i++) {
              left[i - l] = arr[i];
          }
          for (int i = mid + 1; i <= r; i++) {
              right[i - (mid + 1)] = arr[i];
          }
          int left_start = 0;
          int right_start = 0;
          int left_length = mid - l + 1;
          int right_length = r - mid;
          int temp = l;
          while (left_start < left_length && right_start < right_length) {
              if (left[left_start] < right[right_start]) {
                  arr[temp] = left[left_start++];
              } else {
                  arr[temp] = right[right_start++];
              }
              temp++;
          }
          while (left_start < left_length) {
              arr[temp++] = left[left_start++];
          }
          while (right_start < right_length) {
              arr[temp++] = right[right_start++];
          }
      }
  
      static class pair implements Comparable<pair> {
          int a, b, c;
  
          public pair(int a, int b, int c) {
              this.a = a;
              this.b = b;
              this.c = c;
          }
  
          public int compareTo(pair p) {
              return this.a - p.a;
          }
  
      }
  
      static int count = 1;
      static int[] p = new int[100002];
      static long[] flat_tree = new long[300002];
      static int[] in_time = new int[1000002];
      static int[] out_time = new int[1000002];
      static long[] subtree_gcd = new long[100002];
      static int w = 0;
      static boolean poss = true;
  
      public static void main(String[] args) throws Exception {
          in = new FastReader();
          out = new PrintWriter(System.out);
          int t = ni();
          while (t-- > 0) {
              int n=ni();
              int a=ni();
              int b=ni();
              int[] ans=new int[n];
              for(int i=0;i<n;i++){
                  ans[i]=i+1;
              }
              if(n==2){
                  if(a==0 && b==0){
                      pn("1 2");
                      continue;
                  }else pn("-1");
                  continue;
              }
              if(Math.abs(a-b)>1){
                  pn("-1");
                  continue;
              }
              if(a>b){
                  if(1+(n-3)/2<a){
                      pn("-1");
                      continue;
                  }
                  int count=0;
                  int k=n-2;
                  while(count<a){
                      swap(ans,k,k+1);
                      k-=2;
                      count++;
                  }
                  print(ans);
              }else if(b>a){
                  if(1+(n-3)/2<b){
                      pn("-1");
                      continue;
                  }
                  int count=0;
                  int k=0;
                  while(count<b){
                      swap(ans,k,k+1);
                      k+=2;
                      count++;
                  }
                  print(ans);
              }else{
                  if(n==3 && a!=0 && b!=0){
                      pn("-1");
                      continue;
                  }
                  if(a>(1+(n-4)/2)){
                      pn("-1");
                      continue;
                  }
                  int count=0;
                  int k=n-3;
                  while(count<a){
                      swap(ans,k,k+1);
                      k-=2;
                      count++;
                  }
                  print(ans);
              }
  
          }
          out.flush();
          out.close();
  
      }
      static void print(int[] a){
          for(int i=0;i<a.length;i++)p(a[i]+" ");
          pn("");
      }
  
      static long count(long n) {
          long count = 0;
          while (n != 0) {
              n /= 10;
              count++;
          }
          return count;
      }
  
      static void swap(long a, long b) {
          long temp = a;
          a = b;
          b = temp;
      }
      static void swap(int[] a, int i,int j) {
          int temp = a[i];
          a[i] = a[j];
          a[j] = temp;
      }
  
      static int LcsOfPrefix(String a, String b) {
          int i = 0;
          int j = 0;
          int count = 0;
          while (i < a.length() && j < b.length()) {
              if (a.charAt(i) == b.charAt(j)) {
                  j++;
                  count++;
              }
              i++;
          }
          return a.length() + b.length() - 2 * count;
      }
  
      static void reverse(int[] a, int n) {
          for (int i = 0; i < n / 2; i++) {
              int temp = a[i];
              a[i] = a[n - i - 1];
              a[n - i - 1] = temp;
          }
      }
  
      static char get_char(int a) {
          return (char) (a + 'a');
      }
  
      static void dfs(int i, List<List<Integer>> arr, boolean[] visited, int parent) {
          visited[i] = true;
          for (int v : arr.get(i)) {
              if (!visited[v]) {
                  dfs(v, arr, visited, i);
              }
          }
      }
  
      static int find1(List<Integer> a, int val) {
          int ans = -1;
          int l = 0;
          int r = a.size() - 1;
          while (l <= r) {
              int mid = l + (r - l) / 2;
              if (a.get(mid) >= val) {
                  r = mid - 1;
                  ans = mid;
              } else
                  l = mid + 1;
          }
          return ans;
      }
  
      static int find2(List<Integer> a, int val) {
          int l = 0;
          int r = a.size() - 1;
          int ans = -1;
          while (l <= r) {
              int mid = l + (r - l) / 2;
              if (a.get(mid) <= val) {
                  ans = mid;
                  l = mid + 1;
              } else
                  r = mid - 1;
          }
          return ans;
      }
  
      static void dfs(List<List<Integer>> arr, int node, int parent, long[] val) {
          p[node] = parent;
          in_time[node] = count;
          flat_tree[count] = val[node];
          subtree_gcd[node] = val[node];
          count++;
          for (int adj : arr.get(node)) {
              if (adj == parent)
                  continue;
              dfs(arr, adj, node, val);
              subtree_gcd[node] = gcd(subtree_gcd[adj], subtree_gcd[node]);
          }
          out_time[node] = count;
          flat_tree[count] = val[node];
          count++;
      }
  }