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 os
  import sys
  from io import BytesIO, IOBase
  #-----------------------IMPORTANT  FUNCTIONS ---------------------------------#
  from math import cos, e, pi, ceil, pi, tan, floor, gcd, sqrt, log2, factorial, log10
  from collections import Counter
  from copy import deepcopy
  from string import ascii_lowercase, ascii_uppercase
  from statistics import mean, median, mode
  from bisect import *
  
  alpha = ascii_lowercase
  beta = ascii_uppercase
  
  
  #-----------------------NEXT POWER OF 2---------------------------------------#
  def nextPowerOf2(n):
      p = 1
      if (n and not (n & (n - 1))):
          return n
      while (p < n):
          p <<= 1
      return p
  
  
  #-----------------------COMPOSITE  CHECK---------------------------------------#
  def isComposite(n):
      if (n <= 1):
          return False
      if (n <= 3):
          return False
      if (n % 2 == 0 or n % 3 == 0):
          return True
      i = 5
      while (i * i <= n):
          if (n % i == 0 or n % (i + 2) == 0):
              return True
          i = i + 6
      return False
  
  
  #-----------------------GET DIVISORS 1 TO <=N   ------------------------------#
  def get_Divisors(n):
      arr = []
      i = 1
      while i <= sqrt(n):
          if (n % i == 0):
              if (n / i == i):
                  arr.append(i)
              else:
                  arr.append(i)
                  arr.append(n // i)
          i = i + 1
  
      return arr
  
  
  #----------------------CHECK    PRIMES-----------------------------------#
  def isprime(n):
      if n == 1:
          return 0
      i = 2
      while (i * i <= n):
          if (n % i == 0):
              return 0
          i += 1
      return 1
  
  
  #-----------------------PRE COMPUTED  PRIMES-----------------------------------#
  def Sieve(n):
      prime = [True for i in range(n + 1)]
      prime[0] = False
      prime[1] = False
      p = 2
      while (p * p <= n):
          if (prime[p] == True):
              for i in range(p * p, n + 1, p):
                  prime[i] = False
          p += 1
      return prime
  
  
  #-----------------------LARGER VALUE OF  X,Y,10**9+7 --------------------------#
  def power(x, y, p):
      res = 1
      x = x % p
      if (x == 0):
          return 0
      while (y > 0):
          if ((y & 1) == 1):
              res = (res * x) % p
          y = y >> 1
          x = (x * x) % p
      return res
  
  
  #-----------------------       CREATE MATRIX         --------------------------#
  def create_matrix(n, m):
      mat = [[] for i in range(n)]
      for i in range(n):
          for j in range(m):
              mat[i].append(0)
      return mat
  
  
  # By Default Counter stores the value in decending orderCounter({4: 2, 8: 2, 2: 1, 9: 1}
  # s=sorted(s.items(),key=lambda k:(k[0],k[1])) ---> [(2, 1), (4, 2), (8, 2), (9, 1)]
  # sort 2nd value  from bada se chhota  then(4,2)(8,2)->>(8,2)(4,2) s=sorted(s.items(),key=lambda k:(-k[1],-k[0]))  [(8, 2), (4, 2), (9, 1), (2, 1)]
  # for list pair in a list    s.sort(key=lambda k:(-k[1],-k[0])) [[3, 4], [8, 2], [4, 2]]
  # from functools import cmp_to_key
  # how to use compare ----ss = sorted(s, key=cmp_to_key(compare))
  #-----------------------*****CODE STARTS  HERE*****--------------------------#
  
  
  
  # from queue import Queue
  # from random import *
  
  
  def check(arr):
      for i in range(len(arr)-1):
          if arr[i] > arr[i+1]:
              return False
      return True
  
  
  def main():
      for ttt in range(int(input())):
          n,aa,bb=map(int,input().split())
          if aa+bb<= n-2 and ceil((n-2)/2)>=aa and ceil((n-2)/2)>=bb  and abs(aa-bb)<=1:
              a=[i for i in range(1,n+1)]
              b=deepcopy(a)
              b.reverse()
              if aa==bb:
                 
                  x=aa 
                  for i in range(1,n-1,2):
                      if x:
                          a[i],a[i+1]=a[i+1],a[i]
                          x-=1 
                  print(*a)
              
              elif aa>bb:
                  x=aa
                  for i in range(0,n-1,2):
                      if x:
                          b[i],b[i+1]=b[i+1],b[i]
                          x-=1 
                  print(*b)
              else:
                  x=bb
                  for i in range(0,n-1,2):
                      if x:
                          a[i],a[i+1]=a[i+1],a[i]
                          x-=1 
                  print(*a)
                  
              
                      
              
                      
                      
                  
          else:
              print(-1)
              
           
  
  # Region Fast_______io
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  #sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  def input(): return sys.stdin.readline().rstrip("\r\n")
  
  
  if __name__ == "__main__":
      main()
  