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 Main {
  
  	private static void swap(int[] P, int idx1, int idx2) {
  		int tmp = P[idx1];
  		P[idx1] = P[idx2];
  		P[idx2] = tmp;
  	}
  	
  	
  	public static void main(String[] args) throws Exception {
  		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
  		
  		int T = Integer.parseInt(in.readLine());
  		int[] P = new int[100100];
  		
  		for (int ts=1; ts<=T; ts++) {
  			String[] line = in.readLine().split(" ");
  			int N = Integer.parseInt(line[0]);
  			int A = Integer.parseInt(line[1]);
  			int B = Integer.parseInt(line[2]);
  			
  			if (A + B > N - 2 || Math.abs(A - B) > 1) {
  				out.write("-1\n");
  				out.flush();
  				continue;
  			}
  			
  			if (A == 0 || B == 0) {
  				for (int i=1; i<=N; i++) {
  					P[i] = i;
  				}
  				if (A != 0 || B != 0) {
  					if (A == 0) {
  						swap(P, 2, 1);
  					} else {
  						swap(P, N-1, N);
  					}
  				}
  				
  				out.write(P[1] + "");
  				for (int idx=2; idx<=N; idx++) {
  					out.write(" " + P[idx]);
  				}
  				out.write("\n");
  				out.flush();
  				continue;
  			}
  			
  			for (int i=1; i<=N; i++) {
  				P[i] = 0;
  			}
  			int idx = 2;
  			if (A > B) {
  				idx = 3;
  			}
  			int origOrigB = B;
  			int origB = B;
  			while (B > 0) {
  				P[idx] = B;
  				B--;
  				idx += 2;
  			}
  			for (idx=1; idx<=N; idx++) {
  				if (P[idx] != 0) continue;
  				origB++;
  				P[idx] = origB;
  			}
  			if (A >= origOrigB) {
  				for (idx=1; idx<=N; idx++) {
  					if (P[idx] == 1) {
  						break;
  					}
  				}
  				idx++;
  				int great = N;
  				while (idx <= N) {
  					P[idx] = great;
  					great--;
  					idx++;
  				}
  
  			}
  			
  			out.write(P[1] + "");
  			for (idx=2; idx<=N; idx++) {
  				out.write(" " + P[idx]);
  			}
  			out.write("\n");
  			out.flush();
  		}
  		
  		in.close();
  		out.close();
  	}
  
  }