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.IOException;
  import java.io.InputStreamReader;
  import java.util.*;
  
  public class Solution{
  static long mod=(long)1e9+7;
  static FastScanner sc = new FastScanner();
  public static void solve(){
      int n=sc.nextInt();
      int max=sc.nextInt(),min=sc.nextInt();
      if (min+max>n-2 || abs(min-max)>1) {
        System.out.println("-1");
        return;
      }
      if (n==2 && (min>0 || max>0)) {
      System.out.println("-1");
      return;
      }
      if (n==3 && (min+max>=2)) {
      System.out.println("-1");
      return;
      }
        int[] ans=new int[n];
      if (max==min) {
        int l=1;
        int ind=min+max;
        if (ind>=n) {
          System.out.println("-1");
          return;
        }
        while(ind>=0){
          ans[ind]=l;
          l++;
          ind-=2;
        }
        if (l!=min+2) {
          System.out.println("-1");
          return;
        }
        int r=n;
        ind=min+max-1;
        while(ind>=0){
          ans[ind]=r;
          r--;
          ind-=2;
        }
        if (r!=n-max) {
          System.out.println("-1");
          return;
        }
        for (int i=min+max+1;i<n;i++) {
          ans[i]=l;
          l++;
        }
      }else if(max==min+1){
          int l=1;
        int ind=min+max;
        if (ind>=n) {
          System.out.println("-1");
          return;
        }
        int r=n;
        while(ind>=0){
          ans[ind]=r;
          r--;
          ind-=2;
        }
        if (r!=n-max) {
          System.out.println("-1");
          return;
        }
        ind=min+max-1;
        while(ind>=0){
          ans[ind]=l;
          l++;
          ind-=2;
        }
        if (l!=min+2) {
          System.out.println("-1");
          return;
        }
        for (int i=min+max+1;i<n;i++) {
          ans[i]=r;
          r--;
        }
      }else if(max+1==min){
          int l=1;
        int ind=min+max;
        if (ind>=n) {
          System.out.println("-1");
          return;
        }
        while(ind>=0){
          ans[ind]=l;
          l++;
          ind-=2;
        }
        if (l!=min+1) {
          System.out.println("-1");
          return;
        }
        int r=n;
        ind=min+max-1;
        while(ind>=0){
          ans[ind]=r;
          r--;
          ind-=2;
        }
        if (r!=n-max-1) {
          System.out.println("-1");
          return;
        }
        for (int i=min+max+1;i<n;i++) {
          ans[i]=l;
          l++;
        }
      }
      else{
        System.out.println("-1");
        return;
      }
      for (int i:ans) {
        System.out.print(i+" ");
      }
      System.out.println("");
      }
   public static void main(String[] args) {
    int t = sc.nextInt();
    // int t=1;
    outer: for (int tt = 0; tt < t; tt++) {
      solve();
    }
  }
  static boolean isSubSequence(String str1, String str2,
                                   int m, int n)
      {
          int j = 0;
      for (int i = 0; i < n && j < m; i++)
              if (str1.charAt(j) == str2.charAt(i))
                  j++;
          return (j == m);
      }
  static long log2(long n){
    return (long)((double)Math.log((double)n)/Math.log((double)2));
  }
  static boolean isPrime(int n)
      {
          if (n <= 1)
              return false;
          if (n <= 3)
              return true;
    
          if (n % 2 == 0 || n % 3 == 0)
              return false;
    
          for (int i = 5; i * i <= n; i = i + 6)
              if (n % i == 0 || n % (i + 2) == 0)
                  return false;
    
          return true;
      }
  public static int[] LPS(String s){
    int[] lps=new int[s.length()];
    int i=0,j=1;
    while (j<s.length()) {
      if(s.charAt(i)==s.charAt(j)){
        lps[j]=i+1;
        i++;
        j++;
        continue;
      }else{
        if (i==0) {
          j++;
          continue;
        }
        i=lps[i-1];
        while(s.charAt(i)!=s.charAt(j) && i!=0) {
          i=lps[i-1];
        }
        if(s.charAt(i)==s.charAt(j)){
        lps[j]=i+1;
        i++;
        }
        j++;
      }
    }
    return lps;
  }
  static long getPairsCount(int n, double sum,int[] arr)
      {
          HashMap<Double, Integer> hm = new HashMap<>();
          for (int i = 0; i < n; i++) {
              if (!hm.containsKey((double)arr[i]))
                  hm.put((double)arr[i], 0);
              hm.put((double)arr[i], hm.get((double)arr[i]) + 1);
          }
          long twice_count = 0;
          for (int i = 0; i < n; i++) {
              if (hm.get(sum - arr[i]) != null)
                  twice_count += hm.get(sum - arr[i]);
              if (sum - (double)arr[i] == (double)arr[i])
                  twice_count--;
          }
          return twice_count / 2l;
      }
  static boolean[] sieveOfEratosthenes(int n)
      {
          boolean prime[] = new boolean[n + 1];
          for (int i = 0; i <= n; i++)
              prime[i] = true;
   
          for (int p = 2; p * p <= n; p++)
          {
              if (prime[p] == true)
              {
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
          prime[1]=false;
          return prime;
   }
  static long power(long x, long y, long p)
    {
      long res = 1l; 
      x = x % p;
      if (x == 0)
        return 0;
      while (y > 0)
      {
  
        if ((y & 1) != 0)
          res = (res * x) % p;
        y>>=1;
        x = (x * x) % p;
      }
      return res;
    }
  
  public static int log2(int N)
      {
          int result = (int)(Math.log(N) / Math.log(2));
    
          return result;
      }
  
  ////////////////////////////////////////////////////////////////////////////////////
  ////////////////////DO NOT READ AFTER THIS LINE //////////////////////////////////
  ////////////////////////////////////////////////////////////////////////////////////
  static long modFact(int n, 
                         int p) 
      { 
          if (n >= p) 
              return 0; 
        
          long result = 1l; 
          for (int i = 3; i <= n; i++) 
              result = (result * i) % p; 
        
          return result; 
      } 
        
  static boolean isPalindrom(char[] arr, int i, int j) {
    boolean ok = true;
    while (i <= j) {
      if (arr[i] != arr[j]) {
        ok = false;
        break;
      }
      i++;
      j--;
    }
    return ok;
  }
  
  static int max(int a, int b) {
    return Math.max(a, b);
  }
  
  static int min(int a, int b) {
    return Math.min(a, b);
  }
  
  static long max(long a, long b) {
    return Math.max(a, b);
  }
  
  static long min(long a, long b) {
    return Math.min(a, b);
  }
  
  static int abs(int a) {
    return Math.abs(a);
  }
  
  static long abs(long a) {
    return Math.abs(a);
  }
  
  static void swap(long arr[], int i, int j) {
    long temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  
  static void swap(int arr[], int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  
  static int maxArr(int arr[]) {
    int maxi = Integer.MIN_VALUE;
    for (int x : arr)
      maxi = max(maxi, x);
    return maxi;
  }
  
  static int minArr(int arr[]) {
    int mini = Integer.MAX_VALUE;
    for (int x : arr)
      mini = min(mini, x);
    return mini;
  }
  
  static long maxArr(long arr[]) {
    long maxi = Long.MIN_VALUE;
    for (long x : arr)
      maxi = max(maxi, x);
    return maxi;
  }
  
  static long minArr(long arr[]) {
    long mini = Long.MAX_VALUE;
    for (long x : arr)
      mini = min(mini, x);
    return mini;
  }
  static int lcm(int a,int b){
    return (int)(((long)a*b)/(long)gcd(a,b));
  }
  static int gcd(int a, int b) {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
  
  static long gcd(long a, long b) {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
  
  static void ruffleSort(int[] a) {
    int n = a.length;
    Random r = new Random();
    for (int i = 0; i < a.length; i++) {
      int oi = r.nextInt(n);
      int temp = a[i];
      a[i] = a[oi];
      a[oi] = temp;
    }
    Arrays.sort(a);
  }
  
  public static int binarySearch(int a[], int target) {
    int left = 0;
    int right = a.length - 1;
    int mid = (left + right) / 2;
    int i = 0;
    while (left <= right) {
      if (a[mid] <= target) {
        i = mid + 1;
        left = mid + 1;
      } else {
        right = mid - 1;
      }
      mid = (left + right) / 2;
    }
    return i-1;
  }
  
  
  static class FastScanner {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer("");
  
    String next() {
      while (!st.hasMoreTokens())
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      return st.nextToken();
    }
  
    int nextInt() {
      return Integer.parseInt(next());
    }
  
    int[] readArray(int n) {
      int[] a = new int[n];
      for (int i = 0; i < n; i++)
        a[i] = nextInt();
      return a;
    }
  
    long[] readLongArray(int n) {
      long[] a = new long[n];
      for (int i = 0; i < n; i++)
        a[i] = nextLong();
      return a;
    }
  
    int[][] read2dArray(int n, int m) {
      int arr[][] = new int[n][m];
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
          arr[i][j] = nextInt();
        }
      }
      return arr;
    }
  
    ArrayList<Integer> readArrayList(int n) {
      ArrayList<Integer> arr = new ArrayList<Integer>();
      for (int i = 0; i < n; i++) {
        int a = nextInt();
        arr.add(a);
      }
      return arr;
    }
  
    long nextLong() {
      return Long.parseLong(next());
    }
  }
   static class Pair {
    int val, ind;
  
    Pair(int fr, int sc) {
      this.val = fr;
      this.ind = sc;
    }
  }
  }