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: # cook your dish here
  import sys
  import bisect
  from bisect import bisect_left as lb
  from bisect import bisect_right as rb
  input_=lambda: sys.stdin.readline().strip("\r\n")
  from math import log
  from math import gcd
  from math import atan2,acos
  from random import randint
  sa=lambda :input_()
  sb=lambda:int(input_())
  sc=lambda:input_().split()
  sd=lambda:list(map(int,input_().split()))
  sflo=lambda:list(map(float,input_().split()))
  se=lambda:float(input_())
  sf=lambda:list(input_())
  flsh=lambda: sys.stdout.flush()
  sys.setrecursionlimit(3*10**5)
  mod=10**9+7
  mod1=998244353
  gp=[]
  cost=[]
  dp=[]
  mx=[]
  ans1=[]
  ans2=[]
  special=[]
  specnode=[]
  a=0
  kthpar=[]
  def dfs2(root,par):
      if par!=-1:
          dp[root]=dp[par]+1
      for i in range(1,20):
          if kthpar[root][i-1]!=-1:
              kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
      for child in gp[root]:
          if child==par:continue
          kthpar[child][0]=root
          dfs(child,root)
          
  ans=0
  a=[]
  n,k=0,0
  b=[]
  vis=[]
  tot=0
  time=[]
  time1=[]
  adj=[]
  mx=-1
  eps=0.0000001
  x=0
  pref=[]
  lvl=[]
  gp=[]
  ans=[]
  f=0
  w=[]
  #Fenwick Tree point update range sum
  def update_it(bit,i,val):
      n=len(bit)
      while(i<n):
          bit[i]+=val
          i+=i&(-i)
  def get_ans(bit,i):
      n=len(bit)
      tot=0
      while(i>0):
          tot+=bit[i]
          i-=i&(-i)
      return tot
  def dfs(i,prod,rem,n):
      if rem==0:
          while(i<len(n)):
              prod*=int(n[i])
              i+=1
          return prod
      if i==len(n):
          return prod
      mx=0
      for j in range(9-int(n[i])):
          mx=max(dfs(i+1,(int(n[i])+min(j,rem))*prod,rem-min(j,rem),n),mx)
      return mx
  def hnbhai(tc):
      n,a,b=sd()
      if abs(a-b)>=2 or a+b+2>n:
          print(-1)
          return
      ans=[0]*n
      strt=1
      if a==b:
          for i in range(a+1):
              ans[2*i]=strt
              strt+=1
          for i in range(b+1):
              ans[2*i+1]=strt
              strt+=1
          for i in range(n):
              if ans[i]==0:
                  ans[i]=strt
                  strt+=1
          print(*ans)
          return
      if a>b:
          strt=n
          for i in range(a):
              ans[2*i+1]=strt
              strt-=1
          for i in range(a+1):
              ans[2*i]=strt
              strt-=1
          for i in range(n):
              if ans[i]==0:
                  ans[i]=strt
                  strt-=1
          print(*ans)
          return
      
      for i in range(a+1):
          ans[2*i+1]=strt
          strt+=1
      for i in range(a+2):
          ans[2*i]=strt
          strt+=1
      for i in range(n):
          if ans[i]==0:
              ans[i]=strt
              strt+=1
      print(*ans)
      return
      
  for _ in range(sb()):
      hnbhai(_+1)
  ##case
  
  #.
  