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 static java.lang.Math.max;
  import static java.lang.Math.min;
  import static java.lang.Math.abs;
  import static java.lang.System.out;
  import java.util.*;
  import java.io.*;
  import java.math.*;
  /*
  -> Give your 100%, that's it!
  -> Rules To Solve Any Problem:
      1. Read the problem.
      2. Think About It.
      3. Solve it!
  */
  
  public class Template {
      
  	static int mod = 1000000007;
      static int a = 0, b = 0;
  	public static void main(String[] args){
          FastScanner sc = new FastScanner();
          PrintWriter out = new PrintWriter(System.out);
          int yo = sc.nextInt();
          while (yo-- > 0) {
              int n = sc.nextInt();
              a = sc.nextInt(); b = sc.nextInt();
              ok = false;
              int[] arr = new int[n];
              for(int i = 0; i < n; i++) arr[i] = i+1;
              
              if(n == 2){
                  if(a != 0 || b != 0){
                      out.println("-1");
                  }
                  else {
                      out.println("1 2");
                  }
                  continue;
              }
              if(a == 0 && b == 0){
                  print(arr,out);
                  continue;
              }
              
              // bf
              // List<List<Integer>> list = permute(arr);
              // for(List<Integer> l : list){
              //     for(int e : l){
              //         out.print(e + " ");
              //     }
              //     out.println();
              // }
              // if(list.size() == 0){
              //     out.println(-1);
              // }
              
              int[] which = new int[n];
              if(a > b){
                  int tempA = 0;
                  int tempB = 0;
                  for(int i = 1; i < n-1; i++){
                      if(tempA == a && tempB == b){
                          ok = true;
                          break;
                      }
                      if(i % 2 == 1){
                          which[i] = 1;
                          tempA++;
                      }
                      else {
                          which[i] = 2;
                          tempB++;
                      }
                  }
                  if(!ok && (tempA != a && tempB != b)){
                      out.println(-1);
                  }
                  else {
                      int left = 1;
                      int right = n;
                      for(int i = 1; i < n-1; i++){
                          if(which[i] == 1){
                              which[i] = right--;
                          }
                          else if(which[i] == 2){
                              which[i] = left++;
                          }
                      }
                      which[0] = left++;
                      for(int i = 0; i < n; i++){
                          if(which[i] == 0){
                              which[i] = right--;
                          }
                      }
                      if(valid(which)){
                          print(which,out);    
                      }
                      else {
                          // print(which,out);
                          out.println(-1);
                      }
                  }
              }
              else if(a == b){
                  int tempA = 0;
                  int tempB = 0;
                  for(int i = 1; i < n-1; i++){
                      if(tempA == a && tempB == b){
                          ok = true;
                          break;
                      }
                      if(i % 2 == 1){
                          which[i] = 1;
                          tempB++;
                      }
                      else {
                          which[i] = 2;
                          tempA++;
                      }
                  }
                  if(!ok && (tempA != a && tempB != b)){
                      out.println(-1);
                  }
                  else {
                      int left = 1;
                      int right = n;
                      for(int i = 1; i < n-1; i++){
                          if(which[i] == 1){
                              which[i] = left++;
                          }
                          else if(which[i] == 2){
                              which[i] = right--;
                          }
                      }
                      which[0] = left++;
                      for(int i = 0; i < n; i++){
                          if(which[i] == 0){
                              which[i] = right--;
                          }
                      }
                      if(valid(which)){
                          print(which,out);    
                      }
                      else {
                          // print(which,out);
                          out.println(-1);
                      }
                  }
              }
              else {
                  int tempA = 0;
                  int tempB = 0;
                  for(int i = 1; i < n-1; i++){
                      if(tempA == a && tempB == b){
                          ok = true;
                          break;
                      }
                      if(i % 2 == 1){
                          which[i] = 1;
                          tempB++;
                      }
                      else {
                          which[i] = 2;
                          tempA++;
                      }
                  }
                  if(!ok && (tempA != a && tempB != b)){
                      out.println(-1);
                  }
                  else {
                      int left = 1;
                      int right = n;
                      for(int i = 1; i < n-1; i++){
                          if(which[i] == 1){
                              which[i] = left++;
                          }
                          else if(which[i] == 2){
                              which[i] = right--;
                          }
                      }
                      which[0] = left++;
                      for(int i = 0; i < n; i++){
                          if(which[i] == 0){
                              which[i] = left++;
                          }
                      }
                      if(valid(which)){
                          print(which,out);    
                      }
                      else {
                          // print(which,out);
                          out.println(-1);
                      }
                  }
              }
          }
          out.close();
  	}
      
      
      public static List<List<Integer>> permute(int[] nums) {
          List<List<Integer>> res = new ArrayList<>();
          boolean[] vis = new boolean[nums.length];
          List<Integer> list = new ArrayList<>();
          helper(nums,res,list,vis);
          return res;
      }
      static boolean ok = false;
      public static void helper(int[] nums, List<List<Integer>> res, List<Integer> list, boolean[] vis){
          if(res.size() == 1) return;
          if(list.size() == nums.length){
              if(valid(list)){
                  res.add(new ArrayList<>(list));    
                  ok = true;
              }
              
              return;
          }
          
          for(int i = 0; i < nums.length; i++){
              if(!vis[i]){
                  vis[i] = true;
                  list.add(nums[i]);
                  helper(nums,res,list,vis);
                  list.remove(list.size()-1);
                  vis[i] = false;
              }
          }
      }
     
      static boolean valid(List<Integer> l){
          int da = 0;
          int db = 0;
          for(int i = 1; i < l.size()-1; i++){
              if(l.get(i) > l.get(i-1) && l.get(i) > l.get(i+1)){
                  da++;
              }
              else if(l.get(i) < l.get(i-1) && l.get(i) < l.get(i+1)){
                  db++;
              }
          }
          return da == a && db == b;
      }
      
      static boolean valid(int[] l){
          int da = 0;
          int db = 0;
          for(int i = 1; i < l.length-1; i++){
              if(l[i] > l[i-1] && l[i] > l[i+1]){
                  da++;
              }
              else if(l[i] < l[i-1] && l[i] < l[i+1]){
                  db++;
              }
          }
          return da == a && db == b;
      }
      
      /*
      Source: hu_tao
           Random stuff to try when stuck:
              - use bruteforcer
              - check for n = 1, n = 2, so on
              -if it's 2C then it's dp
              -for combo/probability problems, expand the given form we're interested in
              -make everything the same then build an answer (constructive, make everything 0 then do something)
              -something appears in parts of 2 --> model as graph
              -assume a greedy then try to show why it works
              -find way to simplify into one variable if multiple exist
              -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
              -find lower and upper bounds on answer
              -figure out what ur trying to find and isolate it
              -see what observations you have and come up with more continuations
              -work backwards (in constructive, go from the goal to the start)
              -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
              -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
              -draw something
              -simulate a process
              -dont implement something unless if ur fairly confident its correct
              -after 3 bad submissions move on to next problem if applicable
              -do something instead of nothing and stay organized
              -write stuff down
           Random stuff to check when wa:
              -if code is way too long/cancer then reassess
              -switched N/M
              -int overflow
              -switched variables
              -wrong MOD
              -hardcoded edge case incorrectly
           Random stuff to check when tle:
              -continue instead of break
              -condition in for/while loop bad
           Random stuff to check when rte:
              -switched N/M
              -long to int/int overflow
              -division by 0
              -edge case for empty list/data structure/N=1
        */
  
  	public static class Pair {
  		int x;
  		int y;
  
  		public Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  	}
  
  	public static void sort(int[] arr) {
  		ArrayList<Integer> ls = new ArrayList<Integer>();
  		for (int x : arr)
  			ls.add(x);
  		Collections.sort(ls);
  		for (int i = 0; i < arr.length; i++)
  			arr[i] = ls.get(i);
  	}
  
  	public static long gcd(long a, long b) {
  		if (b == 0)
  			return a;
  		return gcd(b, a % b);
  	}
  
  	static boolean[] sieve(int N) {
  		boolean[] sieve = new boolean[N + 1];
  		for (int i = 2; i <= N; i++)
  			sieve[i] = true;
  
  		for (int i = 2; i <= N; i++) {
  			if (sieve[i]) {
  				for (int j = 2 * i; j <= N; j += i) {
  					sieve[j] = false;
  				}
  			}
  		}
  		return sieve;
  	}
  
  	public static long power(long x, long y, long p) {
  		long res = 1L;
  		x = x % p;
  		while (y > 0) {
  			if ((y & 1) == 1)
  				res = (res * x) % p;
  			y >>= 1;
  			x = (x * x) % p;
  		}
  		return res;
  	}
  
  	public static void print(int[] arr, PrintWriter out) {
  		//for debugging only
  		for (int x : arr)
  			out.print(x + " ");
  		out.println();
  	}
      
      public static int log2(int a){
          return (int)(Math.log(a)/Math.log(2));
      }
      
      public static long ceil(long x, long y){
          return (x + 0l + y - 1) / y;
      }
  
  	static class FastScanner {
  		private int BS = 1 << 16;
  		private char NC = (char) 0;
  		private byte[] buf = new byte[BS];
  		private int bId = 0, size = 0;
  		private char c = NC;
  		private double cnt = 1;
  		private BufferedInputStream in;
  
  		public FastScanner() {
  			in = new BufferedInputStream(System.in, BS);
  		}
  
  		public FastScanner(String s) {
  			try {
  				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
  			} catch (Exception e) {
  				in = new BufferedInputStream(System.in, BS);
  			}
  		}
  
  		private char getChar() {
  			while (bId == size) {
  				try {
  					size = in.read(buf);
  				} catch (Exception e) {
  					return NC;
  				}
  				if (size == -1)
  					return NC;
  				bId = 0;
  			}
  			return (char) buf[bId++];
  		}
  
  		public int nextInt() {
  			return (int) nextLong();
  		}
  
  		public int[] readInts(int N) {
  			int[] res = new int[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = (int) nextLong();
  			}
  			return res;
  		}
  
  		public long[] readLongs(int N) {
  			long[] res = new long[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextLong();
  			}
  			return res;
  		}
  
  		public long nextLong() {
  			cnt = 1;
  			boolean neg = false;
  			if (c == NC)
  				c = getChar();
  			for (; (c < '0' || c > '9'); c = getChar()) {
  				if (c == '-')
  					neg = true;
  			}
  			long res = 0;
  			for (; c >= '0' && c <= '9'; c = getChar()) {
  				res = (res << 3) + (res << 1) + c - '0';
  				cnt *= 10;
  			}
  			return neg ? -res : res;
  		}
  
  		public double nextDouble() {
  			double cur = nextLong();
  			return c != '.' ? cur : cur + nextLong() / cnt;
  		}
  
  		public double[] readDoubles(int N) {
  			double[] res = new double[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextDouble();
  			}
  			return res;
  		}
  
  		public String next() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c > 32) {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public String nextLine() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c != '\n') {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public boolean hasNext() {
  			if (c > 32)
  				return true;
  			while (true) {
  				c = getChar();
  				if (c == NC)
  					return false;
  				else if (c > 32)
  					return true;
  			}
  		}
  	}
  
  	//	For Input.txt and Output.txt	
  	//	FileInputStream in = new FileInputStream("input.txt");
  	//	FileOutputStream out = new FileOutputStream("output.txt");
  	//	PrintWriter pw = new PrintWriter(out);
  	//	Scanner sc = new Scanner(in);
  }