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.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map.Entry;
  import java.util.PriorityQueue;
  import java.util.StringTokenizer;
   
  public class Main {
  	static FastReader fr;
  	static int arrForIndexSort[];
  	static class FastReader {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
   
          int nextInt() { return Integer.parseInt(next()); }
   
          long nextLong() { return Long.parseLong(next()); }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
   
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  	static class Pair{
  		int first;
  		int second;
  		Pair(int first, int second){
  			this.first = first;
  			this.second = second;
  		}
  		@Override
  		public boolean equals(Object b) {
  			Pair a = (Pair)b;
  			if(this.first == a.first && this.second==a.second) {
  				return true;
  			}
  			return false;
  		}
  	}
  	class PairSorter implements Comparator<Main.Pair>{
  		public int compare(Pair a, Pair b) {
  			if(a.first!=b.first) {
  				return a.first-b.first;
  			}
  			return a.second-b.second; 
  		}
  	}
  	static class DoublePair{
  		double first;
  		double second;
  		DoublePair(double first, double second){
  			this.first = first;
  			this.second = second;
  		}
  		@Override
  		public boolean equals(Object b) {
  			Pair a = (Pair)b;
  			if(this.first == a.first && this.second==a.second) {
  				return true;
  			}
  			return false;
  		}
  	}
  	class DoublePairSorter implements Comparator<Main.DoublePair>{
  		public int compare(DoublePair a, DoublePair b) {
  			 if(a.second>b.second) {
  				 return 1;
  			 }
  			 else if(a.second<b.second) {
  				 return -1;
  			 }
  			 return 0;
  		}
  	}
  	class IndexSorter implements Comparator<Integer>{
  		public int compare(Integer a, Integer b) {
  			//desc
  			if(arrForIndexSort[b]==arrForIndexSort[a]) {
  				return b-a;
  			}
  			return arrForIndexSort[b]-arrForIndexSort[a];
  		}
  	}
  	class ListSorter implements Comparator<List>{
  		public int compare(List a, List b) {
  			return b.size()-a.size(); 
  		}
  	}
  	static class DisjointSet{
  		int[] dsu;
  		public DisjointSet(int n) {
  			makeSet(n);
  		}
  		public void makeSet(int n) {
  			dsu = new int[n+1];
  			//*** 1 Based indexing ***
  			for(int i=1;i<=n;i++) {
  				dsu[i] = -1;
  			}
  		}
  		public int find(int i) {
  			while(dsu[i] > 0) {
  				i = dsu[i];
  			}
  			return i;
  		}
  		public void union(int i, int j) {
  			int iRep = find(i);
  			int jRep = find(j);
  			if(iRep == jRep) {
  				return;
  			}
  			if(dsu[iRep]>dsu[jRep]) {
  				dsu[jRep] += dsu[iRep];
  				dsu[iRep] = jRep;
  			}
  			else {
  				dsu[iRep] += dsu[jRep];
  				dsu[jRep] = iRep;
  			}
  		}
  	}
  	public static void main(String[] args) {
  		fr = new FastReader();
  		int T = 1;
  		T = fr.nextInt();
  		int t1 = T;
  		while (T-- > 0) {
  			solve();
  		}
  	}
  	public static void solve() {
  		int n = fr.nextInt();
  		int a = fr.nextInt();
  		int b = fr.nextInt();
  		int min = 1;
  		int max = n;
  		int total = n;
  		int count = Math.max(a, b)*2+1;
  		if(a==b) {
  			count++;
  		}
  		if(Math.abs(a-b)>1 || count>n) {
  			System.out.println(-1);
  		}else {
  			StringBuilder sb = new StringBuilder();
  			int lastappended = 0;
  			if(a==0 && b==0) {
  				for(int i=1;i<=n;i++) {
  					sb.append(i).append(" ");
  				}
  			}
  			else if(a>=b) {
  				int temp = a;
  				boolean isMax = true;
  				int starter = min = 1;
  				int ender = max = count;
  				if(a>b) {
  					starter = min = n-count+1;
  					max = n;
  				}
  				sb.append(min++).append(" ");
  				lastappended = min-1;
  				while(temp>0) {
  					if(isMax) {
  						lastappended = max--;
  						temp--;
  					}
  					else {
  						lastappended = min++;
  					}
  					isMax = !isMax;
  					sb.append(lastappended).append(" ");
  				}
  				lastappended = min++;
  				sb.append(lastappended).append(" ");
  				if(a==b) {
  					sb.append(max--).append(" ");
  					lastappended = max+1;
  				}
  				int tempcount = n-count;
  				while(tempcount-->0) {
  					if(a==b) {
  						sb.append(++ender).append(" ");
  					}
  					else {
  						sb.append(--starter).append(" ");
  					}
  				}
  			}
  			else {
  				boolean isMax = false;
  				min = 1;
  				int starter = max = count;
  				sb.append(max--).append(" ");
  				lastappended = max+1;
  				int temp = b;
  				while(temp>0) {
  					if(isMax) {
  						lastappended = max--;
  					}
  					else {
  						lastappended = min++;
  						temp--;
  					}
  					isMax = !isMax;
  					sb.append(lastappended).append(" ");
  				}
  				lastappended = max--;
  				sb.append(lastappended).append(" ");
  				int tempcount = n-count;
  				while(tempcount-->0) {
  					sb.append(++starter).append(" ");
  				}
  			}
  			
  			System.out.println(sb.toString());
  
  		}
  		
  		
  	}
  
  }