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 collections
  # import random
  # import math
  # import itertools
  # import math
  # mport math
  import bisect
  # from collections import defaultdict
  # import itertools
  # from sys import stdin, stdout
  # import math
  # import math
  # import bisect
  # import bisect
  # import collections
  # import itertools
  # import math
  import collections
  import itertools
  import sys
  
  # import operator
  # from decimal import Decimal
  
  # sys.setrecursionlimit(10**6)
  
  
  
  
  
  p2D = lambda x: print(*x, sep="\n")
  
  
  def II(): return int(sys.stdin.buffer.readline())
  
  
  def MI(): return map(int, sys.stdin.buffer.readline().split())
  
  
  def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
  
  
  def LLI(rows_number): return [LI() for _ in range(rows_number)]
  
  
  def BI(): return sys.stdin.buffer.readline().rstrip()
  
  
  def SI(): return sys.stdin.buffer.readline().rstrip().decode()
  
  
  def li(): return [int(i) for i in input().split()]
  
  
  def lli(rows): return [li() for _ in range(rows)]
  
  
  def si(): return input()
  
  
  def ii(): return int(input())
  
  
  def ins(): return input().split()
  
  
  # mod = 10**9+7
  # fval = [1]
  # for i in range(1,200001):
  #     x = (fval[-1]*i)%mod
  #     fval.append(x)
  #
  # ifac = [1]*(200001)
  # ifac[200000] = pow(fval[200000], -1, mod)
  # for i in range(200000-1, 1, -1): ifac[i] = ifac[i+1]*(i+1)%mod
  # _________________ For taking Input from the Text Files __________________
  # import os.path
  #
  # if (os.path.exists('input.txt')):
  #     sys.stdin = open("input.txt", "r")
  #     sys.stdout = open("output.txt", "w")
  #     sys.stderr = open("error.txt", "w")
  
  def drank(d, processing, da, rank):
      tmp = 10 ** 9
      if len(d[da]) == 1:
          return 1
      for di in d[da]:
          if processing[di - 1] == 0:
              processing[di - 1] = 1
              tmp = min(tmp, drank(d, processing, di, rank))
              processing[di - 1] = 0
      rank[da - 1] = tmp + 1
      return tmp + 1
  
  
  
  def binary_search(n, a):
      l = len(a)
      low = 0
      high = l-1
      while high>=low:
          mid = (high+low)//2
          if a[mid] == n:
              return mid
          elif a[mid]>n:
              high = mid-1
          else:
              low = mid+1
      return -1
  
  is_prime = [True]*(10**6+1)
  def primeseive(n):
      is_prime[0] = is_prime[1] = False
      i = 2
      while i*i<=n:
          if is_prime[i] == True:
              for j in range(i*i,n+1,i):
                  is_prime[j] = False
          i+=1
  
  
  def solve():
      n, a, b = LI()
      if a == 0 and b == 0:
          return ' '.join(map(str, [i for i in range(1,n+1)]))
      if n % 2 == 0:
          if a > (n // 2) - 1 or b > (n // 2) - 1:
              return -1
          else:
              if abs(a - b) > 1:
                  return -1
              x = [i for i in range(1, n // 2 + 1)]
              y = [i for i in range(n // 2 + 1, n + 1)]
              ans = []
              if a > b:
                  for j in range(n // 2):
                      ans.append(x[j])
                      ans.append(y[j])
              else:
                  for j in range(n // 2):
                      ans.append(y[j])
                      ans.append(x[j])
              # print(ans)
              i = 1
              while a > 0 and b > 0 and i < n - 1:
                  if ans[i] > ans[i - 1] and ans[i] > ans[i + 1]:
                      a -= 1
                  elif ans[i] < ans[i - 1] and ans[i] < ans[i + 1]:
                      b -= 1
                  i += 1
              if a == 1:
                  ans = ans[:i + 1] + sorted(ans[i + 1:], reverse=True)
              else:
                  ans = ans[:i + 1] + sorted(ans[i + 1:])
              return ' '.join(map(str, ans))
  
  
      else:
          if a > (n // 2) or b > (n // 2):
              return -1
          elif a == (n // 2) and b == (n // 2):
              return -1
          else:
              if abs(a - b) > 1:
                  return -1
  
              ans = []
              if a > b:
                  x = [i for i in range(1, n // 2 + 2)]
                  y = [i for i in range(n // 2 + 2, n + 1)]
                  for j in range(n // 2):
                      ans.append(x[j])
                      ans.append(y[j])
                  ans.append(x[-1])
              else:
                  x = [i for i in range(1, n // 2 + 1)]
                  y = [i for i in range(n // 2 + 1, n + 1)]
                  for j in range(n // 2):
                      ans.append(y[j])
                      ans.append(x[j])
                  ans.append(y[-1])
              # print(ans)
              i = 1
              while a > 0 and b > 0 and i < n - 1:
                  if ans[i] > ans[i - 1] and ans[i] > ans[i + 1]:
                      a -= 1
                  elif ans[i] < ans[i - 1] and ans[i] < ans[i + 1]:
                      b -= 1
                  i += 1
  
              if a == 1:
                  ans = ans[:i + 1] + sorted(ans[i + 1:], reverse=True)
              else:
                  ans = ans[:i + 1] + sorted(ans[i + 1:])
              return ' '.join(map(str, ans))
  
  
  def main():
      #primeseive(10**6)
      #print(is_prime)
      for _ in range(II()):
      #solve()
          sys.stdout.write(str(solve()) + "\n")
      # print(solve())
  
      #     z += str(ans) + '\n'
      # print(len(ans), ' '.join(map(str, ans)), sep='\n')
      # stdout.write(z)
  
  
  # for interactive problems
  # print("? {} {}".format(l,m), flush=True)
  # or print this after each print statement
  # sys.stdout.flush()
  
  
  if __name__ == "__main__":
      main()