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.*;
  import java.util.*;
  public class solution {
  
  public static void main(String[] args)  {
  	FScanner sc = new FScanner();
  	//Arrays.fill(prime, true);
  	//sieve();
  	int t=sc.nextInt();
  //	 StringBuilder sb = new StringBuilder();
  	while(t-->0) {	
  	int n=sc.nextInt();
  	int a=sc.nextInt();
  	int b=sc.nextInt();
  	
  	if(n-2<a+b || Math.abs(a-b)>1 )
  	{
  		System.out.println(-1);
  	}
  	else
  	{
  	int arr[]=new int[n];
  	
  	for(int k=0;k<n;k++)
  	{
  		arr[k]=k+1;
  	}
  	
  	if(a>b)
  	{
  		int i=n-1;
  		while(a>0)
  		{
  			int temp=arr[i];
  			arr[i]=arr[i-1];
  			arr[i-1]=temp;
  			a--;
  			i=i-2;
  		}
  	}
  	else if(b>a)
  	{
  		int i=0;
  		while(b>0)
  		{
  			int temp=arr[i];
  			arr[i]=arr[i+1];
  			arr[i+1]=temp;
  			b--;
  			i=i+2;
  		}
  	}
  	else
  	{
  		int i=1;
  		while(a>0)
  		{
  			int temp=arr[i];
  			arr[i]=arr[i+1];
  			arr[i+1]=temp;
  			a--;
  			i=i+2;
  		}
  	}
  	
  	for(int k=0;k<n;k++)
  	{
  		System.out.print(arr[k]+" ");
  	}
  	System.out.println();
  	}
  	
  	}
  }
  
  
          
   /* public static void sieve()
  {   prime[0]=prime[1]=false;
  int n=1000000;
  	for(int p = 2; p*p <=n; p++)
      {
          if(prime[p] == true)
          {
            
              for(int i = p*p; i <= n; i += p)
                  prime[i] = false;
          }
      }
     */
  }
   
  /*  class pair implements Comparable<pair>{
  	int val;int edge;
  	 pair(int f,int ind)
  	{
  		val=f;
  		edge=ind;
  	}
  	public int compareTo(pair p)
  	{
  		return -p.edge+this.edge;
  	}
  	
  }  */
   
   class FScanner {
  	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  	StringTokenizer sb = new StringTokenizer("");
   
  	String next(){
  		while(!sb.hasMoreTokens()){
  			try{
  				sb = new StringTokenizer(br.readLine());
  			} catch(IOException e){ }
  		}
  		return sb.nextToken();
  	}
  	String nextLine(){
  		try{ return br.readLine(); } 
  		catch(IOException e) { } return "";
  	}
   
  	int nextInt(){
  		return Integer.parseInt(next());
  	}
   
  	long nextLong() {
  		return Long.parseLong(next());
  	}
   
  	int[] readArray(int n) {
  		int a[] = new int[n];
  		for(int i=0;i<n;i++) a[i] = nextInt();
  		return a;
  	}
   
  	float nextFloat(){
  	return Float.parseFloat(next());
  	}
  	
  	double nextDouble(){
  	return Double.parseDouble(next());
  	}
  }