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: try:
      import sys
  #     from _future_ import division, print_function
  #     import bisect 
      import math
      # import heapq
      import collections
  #     i_m = 9223372036854775807
      M = 10**9+7
      
      # def matrix(n):
      #     #matrix input
      #     return [list(map(int, input().split()))for i in range(n)]
      
  #     def string2intlist(s):
  #         return list(map(int, s))
      
      
  #     def calculate_sum(a, N):  # sum of a to N
  #         # Number of multiples
  #         m = N / a
  #         # sum of first m natural numbers
  #         sum = m * (m + 1) / 2
  #         # sum of multiples
  #         ans = a * sum
  #         return ans
      
      
  #     def series(N):
  #         return (N*(N+1))//2
      
      
  #     def count2Dmatrix(i, list):
  #         return sum(c.count(i) for c in list)
      
      
  #     def modinv(n, p):
  #         return pow(n, p - 2, p)
      
      
  #     def nCr(n, r):
  #         i = 1
  #         while i < r:
  #             n *= (n - i)
  #             i += 1
  #         return n // math.factorial(r)
      
      
  #     def GCD(x, y):
  #         x = abs(x)
  #         y = abs(y)
  #         if(min(x, y) == 0):
  #             return max(x, y)
  #         while(y):
  #             x, y = y, x % y
  #         return x
      
      
  #     def LCM(x, y):
  #         return (x * y) // GCD(x, y)
      
      
      # def Divisors(n):
      #     l = []
      #     for i in range(1, int(math.sqrt(n) + 1)):
      #         if (n % i == 0):
      #             if (n // i == i):
      #                 l.append(i)
      #             else:
      #                 l.append(i)
      #                 l.append(n//i)
      #     return l
      
      
      # def isprime(n):
      #     for i in range(2, int(math.sqrt(n))+1):
      #         if n % i == 0:
      #             return False
      #     return True
  
      # def isprime(n): 
      #     if(n <= 1): 
      #         return False
      #     if(n <= 3): 
      #         return True
      #     if(n % 2 == 0 or n % 3 == 0): 
      #         return False
      #     for i in range(5,int(math.sqrt(n) + 1), 6): 
      #         if(n % i == 0 or n % (i + 2) == 0): 
      #             return False 
      #     return True
  
     
      # maxn  = 1000100
      # def SieveOfEratosthenes():
      #     prime = [True for i in range(maxn+1)]
      #     prime[0] = False
      #     prime[1] = False
      #     p = 2
      #     while (p * p <= maxn):
      #         if (prime[p] == True):
      #             for i in range(p * p, maxn+1, p):
      #                 prime[i] = False
      #         p += 1
      #     return prime
      
      
  #     q = []
      
      
  #     def dfs(n, d, v, c):
  #         global q
  #         v[n] = 1
  #         x = d[n]
  #         q.append(n)
  #         j = c
  #         for i in x:
  #             if i not in v:
  #                 f = dfs(i, d, v, c+1)
  #                 j = max(j, f)
  #                 # print(f)
  #         return j
  #     # d = {}
      
      
  #     def knapSack(W, wt, val, n):
  #         K = [[0 for x in range(W + 1)] for x in range(n + 1)]
  #         for i in range(n + 1):
  #             for w in range(W + 1):
  #                 if i == 0 or w == 0:
  #                     K[i][w] = 0
  #                 elif wt[i-1] <= w:
  #                     K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]],  K[i-1][w])
  #                 else:
  #                     K[i][w] = K[i-1][w]
      
  #         return K[n][W]
      
      
      # def modularExponentiation(x, n):
      #     if(n == 0):
      #         return 1
      #     elif (n % 2 == 0):  # n is even
      #         return modularExponentiation((x*x) % M, n//2)
      #     else:  # n is odd
      #         return (x * modularExponentiation((x * x) % M, (n - 1) // 2)) % M
      
       # def powerOftwo(n):
      #     return n and (not (n & (n-1)))
      
  #     def modInverse(a, m):
  #         m0 = m
  #         y = 0
  #         x = 1
      
  #         if (m == 1):
  #             return 0
      
  #         while (a > 1):
      
  #             # q is quotient
  #             q = a // m
      
  #             t = m
      
  #             # m is remainder now, process
  #             # same as Euclid's algo
  #             m = a % m
  #             a = t
  #             t = y
      
  #             # Update x and y
  #             y = x - q * y
  #             x = t
      
  #         # Make x positive
  #         if (x < 0):
  #             x = x + m0
      
  #         return x
      # temp = [0]*101 
  #     def mapi(l,r):
  #         idx = -1
  #         val = -1
  #         if(l > r):
  #             return 0
  #         if(l == r):
  #             return l
  #         for l in range(l,r+1):
  #             if temp[l]>val:
  #     	        idx = l
  #     	        val = temp[l]
  #         return idx
      def solve():
          # x = int(input())
          # d = collections.defaultdict(list)
          # n,k = map(int,input().split())
          # n = int(input())
          # arr = []
          # temp = 2
          # for i in range(n):
          #     arr.append(temp)
          #     temp += 1
          # # return arr
          # string = ""
          # for i in arr:
          #     string += str(i) + " "
          n,a,b = map(int,input().split())
          if(abs(b - a) > 1):
              return -1
          if(a + b > n-2):
              return -1
          temp = []
          for i in range(1 , n+1):
              temp.append(i)
          if(a  ==  b):
              for i in range(1, n, 2):
                  if(a > 0):
                      temp[i] , temp[i+1] = temp[i+1] , temp[i]
                      a -= 1 
                  
          elif(a > b):
              index = n
              for i in range(1 , n , 2):
                  if(b > 0):
                      temp[i] , temp[i+1] = temp[i+1] , temp[i]
                      b -= 1
                  else:
                      index = i
                      break
              t = temp[index:]
              t.reverse()
              temp = temp[:index] + t
          else:
              temp = temp[::-1]
              # print(temp)
              for i in range(1 , n , 2):
                  if(a > 0):
                      temp[i] , temp[i+1] = temp[i+1] , temp[i]
                      a -= 1
                  else:
                      index = i
                      break
              # print(index)
              t = temp[index:]
              t.reverse()
              temp = temp[:index] + t
          
          
          string = ""
          for i in temp:
              string += str(i) + " "
          return string
          # t1 = list(map(int,input().split()))
          temp = modularExponentiation(2,n)-1
          return modularExponentiation(temp,k)
      test = int(input())
      count1 = 1
      while count1<=test:
          ans = solve()
          # sys.stdout.write("Case #" + str(count1) + ": " + str(ans) + "\n")
          sys.stdout.write(str(ans) + "\n")
          count1 += 1
  except EOFError:
      print("")