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 ComdeFormces {
  	
  	public static void main(String[] args) throws Exception{
  		// TODO Auto-generated method stub
  		FastReader sc=new FastReader();
  		BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
  		int t=sc.nextInt();
  		while(t--!=0) {
  		int n=sc.nextInt();
  		int a=sc.nextInt();
  		int b=sc.nextInt();
  		
  			int arr[]=new int[n];
  			for(int i=1;i<=n;i++) {
  				arr[i-1]=i;
  			}
  			if(a>b) {
  				for(int i=n-2;i>=0;i-=2) {
  					if(a==0 && b==0)break;
  					int temp=arr[i];
  				    arr[i]=arr[i+1];
  				    arr[i+1]=temp;
  						
  				    if(i+2<n && i-1>=0) {
  						a--;
  						b--;
  						}
  					else if(i==n-2){
  								if(arr[i]<arr[i+1] && i-1>=0 && arr[i]<arr[i-1])b--;
  								else if(arr[i]>arr[i+1] && i-1>=0 && arr[i]>arr[i-1])a--;
  							}
  					else if(i==0) {
  						   if(arr[i+1]<arr[i] && i+2<n && arr[i+1]<arr[i+2])b--;
  						   else if(arr[i+1]>arr[i] && i+2<n && arr[i+1]>arr[i+2])a--;
  					}
  				}
  			}
  			else {
  				int s=1;
  				if(a==b)s=2;
  				for(int i=s;i<n;i+=2) {
  					if(a==0 && b==0)break;
  					int temp=arr[i];
  					arr[i]=arr[i-1];
  					arr[i-1]=temp;
  							if(i-2>=0 && i+1<n) {
  							a--;
  							b--;
  							}
  							else if(i==n-1) {
  								if(arr[i-1]>arr[i] && i-2>=0 && arr[i-1]>arr[i-2])a--;
  								else if(arr[i-1]<arr[i] && i-2>=0 && arr[i-1]<arr[i-2])b--;
  							}
  							else if(i==1) {
  								if(arr[i]>arr[i-1] && i+1<n && arr[i]>arr[i+1])a--;
  								else if(arr[i]<arr[i-1] && i+1<n && arr[i]<arr[i+1])b--;
  							}
  				}
  			}
  		if(a==0 && b==0) {
  			for(int i=0;i<n;i++) {
  				log.write(arr[i]+" ");
  			}
  		}
  		else log.write("-1");
  		log.write("\n");
  		log.flush();
  		
  		}
  		
  	}
  	
  static long bs(long end ,long cnt,long prev,long n) {
  	long start=1;
  	long st=end;
      while(start<=end) {
      	long mid=start+(end-start)/2;
      	if(mid*cnt+prev==n)return mid;
      	else if(mid*cnt+prev>n)end=mid-1;
      	else start=mid+1;
      }
      if(start<=st && start*cnt+prev>=n)return start;
  	return -1;
  }	
  	
  	
  //utils	
  	
  	static void mergesort(long[] a,int start,int end) {
  		if(start>=end)return;
  		int mid=start+(end-start)/2;
  		mergesort(a,start,mid);
  		mergesort(a,mid+1,end);
  		merge(a,start,mid,end);
  	}
  	static void merge(long []a, int start,int mid,int end) {
  		int ptr1=start;
  		int ptr2=mid+1;
  		long b[]=new long[end-start+1];
  		int i=0;
  		while(ptr1<=mid && ptr2<=end) {
  			if(a[ptr1]<=a[ptr2]) {
  				b[i]=a[ptr1];
  				ptr1++;
  				i++;
  			}
  			else {
  				b[i]=a[ptr2];
  				ptr2++;
  				i++;
  			}
  		}
  		while(ptr1<=mid) {
  			b[i]=a[ptr1];
  			ptr1++;
  			i++;
  		}
  		while(ptr2<=end) {
  			b[i]=a[ptr2];
  			ptr2++;
  			i++;
  		}
  		for(int j=start;j<=end;j++) {
  			a[j]=b[j-start];
  		}
  	}
  	public static class FastReader {
  
  		BufferedReader b;
  		StringTokenizer s;
  		public FastReader() {
  			b=new BufferedReader(new InputStreamReader(System.in));
  		}
  		String next() {
  			while(s==null ||!s.hasMoreElements()) {
  				try {
  					s=new StringTokenizer(b.readLine());
  				}
  				catch(IOException e) {
  					e.printStackTrace();
  				}
  			}
  			return s.nextToken();
  		}
  		public int nextInt() {
  			return Integer.parseInt(next());
  		}
  		public long nextLong() {
  			return Long.parseLong(next());
  		}
  		public double nextDouble() {
  			return Double.parseDouble(next());
  		}
  		String nextLine() {
  			String str="";
  			try {
  				str=b.readLine();
  			}
  			catch(IOException e) {
  				e.printStackTrace();
  			}
  			return str;
  		}
  		boolean hasNext() {
  		    if (s != null && s.hasMoreTokens()) {
  		        return true;
  		    }
  		    String tmp;
  		    try {
  		        b.mark(1000);
  		        tmp = b.readLine();
  		        if (tmp == null) {
  		            return false;
  		        }
  		        b.reset();
  		    } catch (IOException e) {
  		        return false;
  		    }
  		    return true;
  		}
  }
  }
  