You are given three integers $n, a, b$. Determine if there exists a permutation $p_1, p_2, \ldots, p_n$ of integers from $1$ to $n$, such that:

There are exactly $a$ integers $i$ with $2 \le i \le 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 \le i \le 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 \le t \le 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 \leq n \leq 10^5$, $0 \leq a,b \leq 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.


-----Examples-----

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.

Source: codeforces | Difficulty: EASY
Tags: Greedy algorithms

Constructive algorithms


Solutions:
for s in [*open(0)][1:]:
	(n, a, b) = map(int, s.split())
	r = (-1,)
	if -2 < a - b < 2 and a + b < n - 1:
		(*r,) = range(1, n + 1)
		j = a >= b
		k = a > b
		for i in [*range(2 - j, a + b - k + j, 2)] + ([(n - 2) * k], [])[a == b]:
			r[i:i + 2] = (r[i + 1], r[i])
	print(*r)


from sys import stdin
input = stdin.readline
from collections import deque
T = int(input())

def possible(n, a, b):
	if a + b > n - 2:
		return False
	if abs(a - b) >= 2:
		return False
	if a <= (n - 2) // 2 and b <= (n - 2) // 2 + 1:
		return True
	if a <= (n - 2) // 2 + 1 and b <= (n - 2) // 2:
		return True
	return True

def li(n, a, b):
	dq = deque([])
	for i in range(1, n + 1):
		dq.append(i)
	ret = []
	if a == 0 and b == 0:
		return list(range(1, n + 1))
	elif a > b:
		ret.append(dq.popleft())
		ret.append(dq.pop())
		for _ in range(b):
			ret.append(dq.popleft())
			ret.append(dq.pop())
		if dq:
			for i in reversed(dq):
				ret.append(i)
	elif a == b:
		ret.append(dq.popleft())
		ret.append(dq.pop())
		for _ in range(a - 1):
			ret.append(dq.popleft())
			ret.append(dq.pop())
		if dq:
			for i in dq:
				ret.append(i)
	else:
		ret.append(dq.pop())
		ret.append(dq.popleft())
		for _ in range(a):
			ret.append(dq.pop())
			ret.append(dq.popleft())
		if dq:
			for i in dq:
				ret.append(i)
	return ret
for _ in range(T):
	(n, a, b) = map(int, input().split())
	if not possible(n, a, b):
		print(-1)
		continue
	l = li(n, a, b)
	print(*l)


T = int(input())
for _ in range(T):
	(n, a, b) = map(int, input().split())
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
		continue
	if a == b + 1:
		(lo, hi) = (1, n)
		for i in range(a):
			print(lo, end=' ')
			print(hi, end=' ')
			lo += 1
			hi -= 1
		while hi >= lo:
			print(hi, end=' ')
			hi -= 1
		print()
	elif b == a + 1:
		(lo, hi) = (1, n)
		for i in range(b):
			print(hi, end=' ')
			print(lo, end=' ')
			lo += 1
			hi -= 1
		while hi >= lo:
			print(lo, end=' ')
			lo += 1
		print()
	else:
		(lo, hi) = (1, n)
		for i in range(a):
			print(lo, end=' ')
			print(hi, end=' ')
			lo += 1
			hi -= 1
		print(lo, end=' ')
		lo += 1
		while hi >= lo:
			print(lo, end=' ')
			lo += 1
		print()


import random
from collections import Counter, defaultdict
from copy import deepcopy as dc
import math
try:
	t = int(input())
	for tt in range(1, t + 1):
		(n, a, b) = map(int, input().split())
		if abs(a - b) > 1 or a + b > n - 2:
			print(-1)
		else:
			x = [i + 1 for i in range(n)]
			if a > b:
				y = x[:n - a]
				(i, j) = (0, 0)
				y.reverse()
				x = x[n - a:]
				while i < len(y):
					x.insert(j, y[i])
					j += 2
					i += 1
				print(*x)
			elif b > a:
				y = x[b:]
				(i, j) = (0, 0)
				x = x[:b]
				while i < len(y):
					x.insert(j, y[i])
					j += 2
					i += 1
				print(*x)
			else:
				y = x[a + 1:]
				(i, j) = (0, 1)
				x = x[:a + 1]
				while i < len(y):
					x.insert(j, y[i])
					j += 2
					i += 1
				print(*x)
except EOFError as e:
	pass


import sys
for _ in range(int(sys.stdin.readline())):
	(n, a, b) = [int(x) for x in sys.stdin.readline().split()]
	if a + b + 2 > n:
		print(-1)
		continue
	if abs(a - b) > 1:
		print(-1)
		continue
	arr = list(range(1, n + 1))
	if a == b:
		i = 1
		while i < n and i // 2 < a:
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			i += 2
	elif a > b:
		i = 1
		while i < n and i // 2 < a - 1:
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			i += 2
		(arr[-1], arr[-2]) = (arr[-2], arr[-1])
	elif a < b:
		arr.reverse()
		i = 1
		while i < n and i // 2 < b - 1:
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			i += 2
		(arr[-1], arr[-2]) = (arr[-2], arr[-1])
	print(' '.join(map(str, arr)))


def max_amount_of_local(n):
	if n == 2:
		return 0
	if n == 3:
		return 1
	if n == 4:
		return 1
	if n == 5:
		return 2
	return (n - 1) // 2

def score(res):
	min_amount = 0
	max_amount = 0
	for i in range(1, len(res) - 1):
		if res[i] > max(res[i - 1], res[i + 1]):
			max_amount += 1
		if res[i] < min(res[i - 1], res[i + 1]):
			min_amount += 1
	return (max_amount, min_amount)

def solve(n, a, b):
	if max_amount_of_local(n) < max(a, b):
		return -1
	if a + b > n - 2:
		return -1
	if abs(a - b) > 1:
		return -1
	if a < b:
		return [n + 1 - val for val in solve(n, b, a)]
	res = [1]
	cur_max = n
	cur_min = 2
	while b > 0:
		res.append(cur_max)
		res.append(cur_min)
		cur_max -= 1
		cur_min += 1
		a -= 1
		b -= 1
	if a == 0:
		for i in range(cur_min, cur_max + 1):
			res.append(i)
		return res
	res.append(cur_max)
	cur_max -= 1
	for i in range(cur_max, cur_min - 1, -1):
		res.append(i)
	return res
T = int(input())
for _ in range(T):
	(n, a, b) = map(int, input().split())
	result = solve(n, a, b)
	if result == -1:
		print(result)
	else:
		print(' '.join(map(str, result)))


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	l = list(range(1, n + 1))
	if a + b <= n - 2 and (max(a, b) - min(a, b) == 1 or max(a, b) - min(a, b) == 0):
		if a > b:
			if a == 1:
				(l[-1], l[-2]) = (l[-2], l[-1])
			else:
				k = 1
				for i in range(a - 1):
					(l[k], l[k + 1]) = (l[k + 1], l[k])
					k = k + 2
				(l[-1], l[-2]) = (l[-2], l[-1])
		if a < b:
			k = 0
			for i in range(b):
				(l[k], l[k + 1]) = (l[k + 1], l[k])
				k = k + 2
		elif a == b:
			k = 1
			for i in range(a):
				(l[k], l[k + 1]) = (l[k + 1], l[k])
				k = k + 2
		for i in l:
			print(i, end=' ')
		print()
	else:
		print(-1)


import os
import sys
from io import BytesIO, IOBase
import math
from heapq import heappop, heappush, heapify
from collections import deque

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def lower_bound(arr, n, k):
	start = 0
	end = n - 1
	while start <= end:
		mid = (start + end) // 2
		if arr[mid] == k:
			return mid
		elif arr[mid] > k:
			if mid > 0:
				if arr[mid - 1] < k:
					return mid - 1
			else:
				return -1
		elif mid < n - 1:
			if arr[mid + 1] > k:
				return mid
		else:
			return mid

def upper_bound(arr, n, k):
	start = 0
	end = n - 1
	while start <= end:
		mid = (start + end) // 2
		if arr[mid] == k:
			return mid
		elif arr[mid] > k:
			if mid > 0:
				if arr[mid - 1] < k:
					return mid
			else:
				return mid
		elif mid < n - 1:
			if arr[mid + 1] > k:
				return mid + 1
		else:
			return -1

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a // gcd(a, b) * b

def helper(arr, n):
	maxx = 0
	minn = 0
	for i in range(1, n - 1):
		if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
			maxx += 1
		elif arr[i] < arr[i - 1] and arr[i] < arr[i + 1]:
			minn += 1
	return (maxx, minn)

def main():
	t = int(input())
	for _ in range(t):
		(n, a, b) = map(int, input().split())
		arr = [i for i in range(1, n + 1)]
		if a == 0 and b == 0:
			for i in range(n):
				print(arr[i], end=' ')
			print()
		elif a > int(math.ceil((n - 2) / 2)):
			print(-1)
		elif b > int(math.ceil((n - 2) / 2)):
			print(-1)
		elif a + b > n - 2:
			print(-1)
		elif abs(a - b) > 1:
			print(-1)
		else:
			if a + b == n - 2:
				if a > b:
					for i in range(1, n, 2):
						(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
				else:
					for i in range(0, n, 2):
						if i < n - 1:
							(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			else:
				x = a + b + 2
				if a > b:
					for i in range(1, x, 2):
						(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
					arr[x - 1:n] = reversed(arr[x - 1:n])
				elif a < b:
					for i in range(0, x - 1, 2):
						(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
				else:
					for i in range(0, x, 2):
						(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
					arr[x - 1:n] = reversed(arr[x - 1:n])
			for i in range(n):
				print(arr[i], end=' ')
			print()
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def main():
	(n, local_max, local_min) = list(map(int, input().split()))
	if abs(local_max - local_min) > 1:
		return [-1]
	if local_max + local_min > n - 2:
		return [-1]
	arr = [0] * n
	if local_max == local_min:
		i = 2
		cur_num = 1
		while local_min > 0:
			arr[i] = cur_num
			i += 2
			local_min -= 1
			cur_num += 1
		for j in range(n):
			if arr[j] == 0:
				arr[j] = cur_num
				cur_num += 1
	elif local_max > local_min:
		i = 1
		cur_num = n
		while local_max > 0:
			arr[i] = cur_num
			i += 2
			local_max -= 1
			cur_num -= 1
		for j in range(n):
			if arr[j] == 0:
				arr[j] = cur_num
				cur_num -= 1
	elif local_min > local_max:
		i = 1
		cur_num = 1
		while local_min > 0:
			arr[i] = cur_num
			i += 2
			local_min -= 1
			cur_num += 1
		for j in range(n):
			if arr[j] == 0:
				arr[j] = cur_num
				cur_num += 1
	return arr
for _ in range(int(input())):
	a = main()
	print(*a)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	if a + b > n - 2:
		print(-1)
		continue
	if abs(a - b) > 1:
		print(-1)
		continue
	arr = [i for i in range(1, n + 1)]
	if a >= b:
		k = a + b
		if k & 1:
			k = k - 1
			i = 2
			while k:
				(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
				i += 2
				k -= 2
			(arr[-1], arr[-2]) = (arr[-2], arr[-1])
		else:
			i = 2
			while k:
				(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
				i += 2
				k -= 2
	else:
		k = a + b
		if k & 1:
			k = k - 1
			i = n - 2
			while k:
				(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
				i -= 2
				k -= 2
			(arr[0], arr[1]) = (arr[1], arr[0])
		else:
			i = n - 2
			while k:
				(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
				i -= 2
				k -= 2
	for x in arr:
		print(x, end=' ')
	print()


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	k = sorted(range(1, n + 1))
	if abs(a - b) > 1:
		print(-1)
		continue
	if n == 2 and (not a + b == 0):
		print(-1)
		continue
	rep = min(a, b)
	if b > a:
		(k[0], k[1]) = (k[1], k[0])
		for i in range(2, 2 * (rep + 1), 2):
			if i + 1 >= n - 1:
				print(-1)
				break
			(k[i], k[i + 1]) = (k[i + 1], k[i])
		else:
			print(*k)
	elif a > b:
		(k[-1], k[-2]) = (k[-2], k[-1])
		for i in range(1, 2 * rep + 1, 2):
			if i + 1 >= n - 2:
				print(-1)
				break
			(k[i], k[i + 1]) = (k[i + 1], k[i])
		else:
			print(*k)
	else:
		for i in range(1, 2 * rep + 1, 2):
			if i + 1 >= n - 1:
				print(-1)
				break
			(k[i], k[i + 1]) = (k[i + 1], k[i])
		else:
			print(*k)


import math

def test():
	(n, a, b) = map(int, input().split())
	if a + b > n - 2 or abs(a - b) > 1:
		print('-1')
	elif a == b:
		i = 2
		s = '1 '
		while a > 0:
			a -= 1
			s += str(i + 1) + ' ' + str(i) + ' '
			i += 2
		for i in range(i, n + 1):
			s += str(i) + ' '
		print(s)
	elif a > b:
		i = 2
		s = '1 '
		while b > 0:
			b -= 1
			s += str(i + 1) + ' ' + str(i) + ' '
			i += 2
		while n >= i:
			s += str(n) + ' '
			n -= 1
		print(s)
	else:
		i = n - 1
		s = str(n) + ' '
		while a > 0:
			a -= 1
			s += str(i - 1) + ' ' + str(i) + ' '
			i -= 2
		n = 1
		while n <= i:
			s += str(n) + ' '
			n += 1
		print(s)
t = int(input())
for i in range(t):
	test()


for z in range(int(input())):
	(n, a, b) = map(int, input().strip().split())
	l = []
	for i in range(1, n + 1):
		l.append(str(i))
	if n < a + b + 2 or b not in (a - 1, a, a + 1):
		print(-1)
	else:
		k = 1
		if a > b:
			(l[-1], l[-2]) = (l[-2], l[-1])
			a -= 1
		elif b > a:
			(l[0], l[1]) = ('2', '1')
			k += 1
			a += 1
		for i in range(k, 2 * a, 2):
			(l[i], l[i + 1]) = (l[i + 1], l[i])
		print(' '.join(l))


import os
import random
import sys
from itertools import *
from io import BytesIO, IOBase

def lcm(a, b):
	return a * b // gcd(a, b)

def sieve():
	global spf, adj, MAXN
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(2, MAXN):
		if i * i > MAXN:
			break
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def getdistinctFactorization(n):
	global adj, spf, MAXN
	for i in range(1, n + 1):
		index = 1
		x = i
		if x != 1:
			adj[i].append(spf[x])
		x = x // spf[x]
		while x != 1:
			if adj[i][index - 1] != spf[x]:
				adj[i].append(spf[x])
				index += 1
			x = x // spf[x]

def printDivisors(n):
	i = 2
	z = [1, n]
	while i <= sqrt(n):
		if n % i == 0:
			if n / i == i:
				z.append(i)
			else:
				z.append(i)
				z.append(n // i)
		i = i + 1
	return z

def create(n, x, f):
	pq = len(bin(n)[2:])
	if f == 0:
		tt = min
	else:
		tt = max
	dp = [[inf] * n for _ in range(pq)]
	dp[0] = x
	for i in range(1, pq):
		for j in range(n - (1 << i) + 1):
			dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << i - 1)])
	return dp

def enquiry(l, r, dp, f):
	if l > r:
		return inf if not f else -inf
	if f == 1:
		tt = max
	else:
		tt = min
	pq1 = len(bin(r - l + 1)[2:]) - 1
	return tt(dp[pq1][l], dp[pq1][r - (1 << pq1) + 1])

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	x = []
	for i in range(2, n + 1):
		if prime[i]:
			x.append(i)
	return x

def solv(z, a, b):
	for i in range(1, len(z) - 1):
		if z[i - 1] < z[i] > z[i + 1]:
			a -= 1
		elif z[i - 1] > z[i] < z[i + 1]:
			b -= 1
	if a == b == 0:
		return True
	return False

def main():
	for _ in range(int(input())):
		(n, a, b) = map(int, input().split())
		if abs(a - b) > 1 or a + b > n - 2:
			print(-1)
		else:
			z = [0] * n
			if a == b:
				i = 1
				z = list(range(1, n + 1))
				for j in range(a):
					(z[i], z[i + 1]) = (z[i + 1], z[i])
					i += 2
			elif a > b:
				pos = 1
				x = n
				for i in range(a):
					z[pos] = x
					pos += 2
					x -= 1
				for i in range(n):
					if z[i] == 0:
						z[i] = x
						x -= 1
			else:
				pos = 1
				x = 1
				for i in range(b):
					z[pos] = x
					pos += 2
					x += 1
				for i in range(n):
					if z[i] == 0:
						z[i] = x
						x += 1
			print(*z)
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import *
from collections import *
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	aa = a
	bb = b
	arr = []
	for i in range(n):
		arr.append(i + 1)
	if b > a:
		flag = 0
		for i in range(0, n - 1, 2):
			if b == 0:
				flag = 1
				break
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			if i == 0:
				b -= 1
			else:
				a -= 1
				b -= 1
			if b == 0:
				flag = 1
				break
		plag = 0
		if a == 0:
			plag = 1
		if a != 0:
			for i in range(n - 1, -1, -2):
				if a == 0:
					plag = 1
					break
				(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
				if i == n - 1:
					a -= 1
				else:
					a -= 1
					b -= 1
				if a == 0:
					plag = 1
					break
		if flag and plag:
			mx = 0
			mn = 0
			for i in range(1, n - 1):
				if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
					mx += 1
				elif arr[i] < arr[i - 1] and arr[i] < arr[i + 1]:
					mn += 1
			if mx == aa and mn == bb:
				print(*arr)
			else:
				print(-1)
		else:
			print(-1)
	else:
		flag = 0
		for i in range(n - 1, -1, -2):
			if a == 0:
				flag = 1
				break
			(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
			if i == n - 1:
				a -= 1
			else:
				a -= 1
				b -= 1
			if a == 0:
				flag = 1
				break
		plag = 0
		if b == 0:
			plag = 1
		if b != 0:
			for i in range(0, n - 1, 2):
				if b == 0:
					plag = 1
					break
				(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
				if i == n:
					b -= 1
				else:
					a -= 1
					b -= 1
				if b == 0:
					plag = 1
					break
		if flag and plag:
			mx = 0
			mn = 0
			for i in range(1, n - 1):
				if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
					mx += 1
				elif arr[i] < arr[i - 1] and arr[i] < arr[i + 1]:
					mn += 1
			if mx == aa and mn == bb:
				print(*arr)
			else:
				print(-1)
		else:
			print(-1)


t = int(input())
for q in range(t):
	(n, a, b) = [int(x) for x in input().split()]
	if max(a, b) * 2 + 1 > n or abs(a - b) > 1:
		print(-1)
		continue
	if b > a:
		r = 2 * b
		arr = [None for i in range(r)]
		for i in range(r):
			if i % 2 == 0:
				arr[i] = r - i // 2
			else:
				arr[i] = i // 2 + 1
		lis = [r + 1 + i for i in range(n - r)]
		print(*arr, *lis)
	elif a == b:
		r = 2 * a + 1
		if r == n:
			print(-1)
			continue
		arr = [None for i in range(r)]
		for i in range(r):
			if i % 2 == 0:
				arr[i] = i // 2 + 1
			else:
				arr[i] = r - i // 2
		lis = [r + 1 + i for i in range(n - r)]
		print(*arr, *lis)
	else:
		r = 2 * a
		arr = [None for i in range(r)]
		for i in range(r):
			if i % 2 == 0:
				arr[i] = i // 2 + 1 + n - r
			else:
				arr[i] = r - i // 2 + n - r
		lis = [n - r - i for i in range(n - r)]
		print(*arr, *lis)


def answer(n: int, up: int, down: int) -> str:
	if up + down > n - 2 or abs(up - down) > 1:
		return '-1'
	common = min(up, down)
	answer = []
	l = 1
	r = n
	if up == down == 0:
		answer = range(1, n + 1)
	elif up > down:
		for i in range(common + 1):
			answer.append(l)
			answer.append(r)
			l += 1
			r -= 1
		answer += list(range(r, l - 1, -1))
	elif up == down:
		for i in range(common):
			answer.append(l)
			answer.append(r)
			l += 1
			r -= 1
		answer += list(range(l, r + 1))
	else:
		for i in range(common + 1):
			answer.append(r)
			answer.append(l)
			l += 1
			r -= 1
		answer += list(range(l, r + 1))
	return ' '.join(map(str, answer))
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	print(answer(n, a, b))


I = input
for _ in range(int(I())):
	(n, a, b) = map(int, I().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		res = list(range(1, n + 1))
		if b > a:
			res = res[::-1]
		for i in range(1, min(a, b) * 2 + 1, 2):
			(res[i], res[i + 1]) = (res[i + 1], res[i])
		if a != b:
			(res[-2], res[-1]) = (res[-1], res[-2])
		print(*res)


for testc in range(int(input())):
	(n, a, b) = list(map(int, input().split()))
	if abs(a - b) >= 2 or a + b > n - 2:
		print(-1)
		continue
	if a > b:
		t = []
		for i in range(a):
			t.extend([i + 1, n - i])
		t.extend(range(n - a, a, -1))
	elif a == b:
		t = [1]
		for i in range(a):
			t.extend([n - i, i + 2])
		t.extend(range(a + 2, n - a + 1))
	else:
		t = [n]
		for i in range(a):
			t.extend([i + 1, n - i - 1])
		t.extend(range(a + 1, n - a))
	print(*t)


import sys
input = sys.stdin.readline
for _ in [0] * int(input()):
	(n, a, b) = map(int, input().split())
	s = [0] * n
	i = 1
	if a == b + 1 and a + b <= n - 2:
		s[0] = b + 1
		for x in range(n, n - b, -1):
			s[i:i + 2] = [x, n - x + 1]
			i = i + 2
		s[i:] = list(range(n - b, b + 1, -1))
	elif b == a + 1 and a + b <= n - 2:
		s[0] = n - a
		for x in range(1, a + 1, 1):
			s[i:i + 2] = [x, n - x + 1]
			i = i + 2
		s[i:] = list(range(a + 1, n - a, 1))
	elif a == b and a + b <= n - 2:
		s[0] = n - a
		for x in range(1, a + 1, 1):
			s[i:i + 2] = [x, n - x + 1]
			i = i + 2
		s[i:] = list(range(n - a - 1, a, -1))
	else:
		s = [-1]
	print(*s)


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	c = [j + 1 for j in range(n)]
	ans = []
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	else:
		if b > a:
			for j in range(min(a, b) + 1):
				ans.append(c[-1])
				ans.append(c[0])
				c.pop()
				c.pop(0)
			ans += c
		elif a > b:
			for j in range(min(a, b) + 1):
				ans.append(c[0])
				ans.append(c[-1])
				c.pop(0)
				c.pop()
			c.reverse()
			ans += c
		else:
			for j in range(a):
				ans.append(c[0])
				ans.append(c[-1])
				c.pop(0)
				c.pop()
			ans.append(c[0])
			c.pop(0)
			ans += c
		for j in range(len(ans)):
			print(ans[j], end=' ')
		print()


def find(n, a, b):
	if abs(a - b) > 1:
		return -1
	if a + b > n - 2:
		return -1
	up = [n - i for i in range(a)]
	down = [i + 1 for i in range(b)]
	combine = [str(b + 1)]
	if a == b:
		for i in range(a):
			combine.append(str(up[i]))
			combine.append(str(down[i]))
	else:
		c = b
		if a < b:
			(up, down) = (down, up)
			c = a
		for i in range(c):
			combine.append(str(up[i]))
			combine.append(str(down[i]))
		combine.append(str(up[-1]))
	if int(combine[-1]) == n - a + 1:
		for i in range(n - a, b + 1, -1):
			combine.append(str(i))
	else:
		for i in range(b + 2, n - a + 1):
			combine.append(str(i))
	return ' '.join(combine)
cases = int(input())
for y in range(cases):
	line = input().split()
	(n, a, b) = (int(line[0]), int(line[1]), int(line[2]))
	print(find(n, a, b))


t = int(input())
for j in range(t):
	(n, a, b) = map(int, input().split())
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	else:
		if a == 0 and b == 0:
			arr = [i for i in range(1, n + 1)]
		elif a > b:
			arr = [i for i in reversed(range(1, n + 1))]
			index = 0
			for j in range(a):
				(arr[index], arr[index + 1]) = (arr[index + 1], arr[index])
				index += 2
		elif b > a:
			arr = [i for i in range(1, n + 1)]
			index = 0
			for j in range(b):
				(arr[index], arr[index + 1]) = (arr[index + 1], arr[index])
				index += 2
		else:
			arr = [i for i in range(1, n + 1)]
			index = 0
			for j in range(a):
				(arr[index], arr[index + 1]) = (arr[index + 1], arr[index])
				index += 2
			(arr[len(arr) - 1], arr[len(arr) - 2]) = (arr[len(arr) - 2], arr[len(arr) - 1])
		for i in range(len(arr)):
			print(arr[i], end=' ')
		print('')


cases = int(input())
func = lambda : [int(q) for q in input().split()]
ans = []
for q in range(cases):
	data = func()
	ans.append([])
	if abs(data[1] - data[2]) > 1 or data[1] + data[2] > data[0] - 2:
		ans[q].append(-1)
	else:
		ans[q] = list(range(1, data[0] + 1))
		if data[1] > data[2]:
			for _ in range(data[2]):
				(ans[q][2 * _ + 1], ans[q][2 * _ + 2]) = (ans[q][2 * _ + 2], ans[q][2 * _ + 1])
			(ans[q][data[0] - 2], ans[q][data[0] - 1]) = (ans[q][data[0] - 1], ans[q][data[0] - 2])
		elif data[1] < data[2]:
			for _ in range(data[2]):
				(ans[q][2 * _], ans[q][2 * _ + 1]) = (ans[q][2 * _ + 1], ans[q][2 * _])
		else:
			for _ in range(data[2]):
				(ans[q][2 * _ + 1], ans[q][2 * _ + 2]) = (ans[q][2 * _ + 2], ans[q][2 * _ + 1])
for q in range(cases):
	for r in range(len(ans[q])):
		print(ans[q][r], end=' ')
	print()


try:
	import sys
	import math
	import collections
	M = 10 ** 9 + 7

	def solve():
		(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]
			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
			t = temp[index:]
			t.reverse()
			temp = temp[:index] + t
		string = ''
		for i in temp:
			string += str(i) + ' '
		return string
		temp = modularExponentiation(2, n) - 1
		return modularExponentiation(temp, k)
	test = int(input())
	count1 = 1
	while count1 <= test:
		ans = solve()
		sys.stdout.write(str(ans) + '\n')
		count1 += 1
except EOFError:
	print('')


t = int(input())
for _ in range(t):
	(n, a, b) = [int(i) for i in input().strip().split()]
	if abs(b - a) > 1 or a + b > n - 2:
		print(-1)
	else:
		arr = [i + 1 for i in range(n)]
		if a < b:
			arr = arr[::-1]
			(a, b) = (b, a)
		i = 1
		j = n - 1
		res = [arr[0]]
		maxima = True
		while a or b:
			if maxima:
				res.append(arr[j])
				j -= 1
				maxima = False
				a -= 1
			else:
				res.append(arr[i])
				i += 1
				maxima = True
				b -= 1
		if maxima:
			print(*res + arr[i:j + 1])
		else:
			print(*res + arr[j:i - 1:-1])


def solve():
	(n, a, b) = map(int, input().split())
	ans = [-1] * n
	if abs(a - b) > 1:
		print(-1)
		return
	if a + b + 2 > n:
		print(-1)
		return
	if a == b:
		ans[a + b + 1:] = [i for i in range(a + b + 2, n + 1)]
		smallest = [i for i in range(1, a + b + 2)]
		(l, r) = (0, len(smallest) - 1)
		for i in range(a + b + 1):
			if i % 2 == 0:
				ans[i] = smallest[l]
				l += 1
			else:
				ans[i] = smallest[r]
				r -= 1
	elif a == b + 1:
		largest = [i for i in range(n - (a + b + 1), n + 1)]
		(l, r) = (0, len(largest) - 1)
		ans[:n - (a + b + 2)] = [i for i in range(1, n - (a + b + 1))]
		for i in range(n - (a + b + 2), n):
			if i % 2 == (n - (a + b + 2)) % 2:
				ans[i] = largest[l]
				l += 1
			else:
				ans[i] = largest[r]
				r -= 1
	else:
		ans[:n - (a + b + 2)] = [i for i in range(n, a + b + 2, -1)]
		smallest = [i for i in range(1, a + b + 3)]
		(l, r) = (0, len(smallest) - 1)
		for i in range(n - (a + b + 2), n):
			if i % 2 == (n - (a + b + 2)) % 2:
				ans[i] = smallest[r]
				r -= 1
			else:
				ans[i] = smallest[l]
				l += 1
	print(*ans)
for _ in range(int(input())):
	solve()


import sys
t = int(input())
for _ in range(t):
	(n, a, b) = [int(x) for x in input().split(' ')]
	if a - b > 1 or b - a > 1 or a + b + 2 > n:
		print('-1')
	elif a >= b:
		(x, y) = (1, n)
		for j in range(a):
			print(x, y, end=' ')
			y = y - 1
			x = x + 1
		if a == b:
			print(x, end=' ')
			for j in range(x + 1, y + 1):
				print(j, end=' ')
		else:
			for j in range(y, x - 1, -1):
				print(j, end=' ')
		print('')
	else:
		(x, y) = (1, n)
		for j in range(b):
			print(y, x, end=' ')
			y = y - 1
			x = x + 1
		for j in range(x, y + 1):
			print(j, end=' ')
		print('')


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	if a + b > n - 2:
		print(-1)
	elif abs(a - b) > 1:
		print(-1)
	else:
		li = []
		ma = n
		mi = 1
		if a > b:
			maflag = 1
			for i in range(a + b):
				if maflag == 1:
					li.append(ma)
					ma -= 1
					maflag = 0
				else:
					li.append(mi)
					mi += 1
					maflag = 1
			li.insert(0, ma)
			ma -= 1
			for i in range(n - a - b - 1):
				li.append(ma)
				ma -= 1
		elif a < b:
			miflag = 1
			for i in range(a + b):
				if miflag == 1:
					li.append(mi)
					mi += 1
					miflag = 0
				else:
					li.append(ma)
					ma -= 1
					miflag = 1
			li.insert(0, mi)
			mi += 1
			for i in range(n - a - b - 1):
				li.append(mi)
				mi += 1
		elif a == b and a != 0:
			maflag = 1
			for i in range(a + b):
				if maflag == 1:
					li.append(ma)
					ma -= 1
					maflag = 0
				else:
					li.append(mi)
					mi += 1
					maflag = 1
			li.insert(0, ma)
			for i in range(n - a - b - 1):
				li.append(mi)
				mi += 1
		else:
			for i in range(1, n + 1):
				li.append(i)
		print(*li)


import math
import os
import random
import re
import sys
t = int(input())
while t > 0:
	t -= 1
	s = input().split()
	n = int(s[0])
	a = int(s[1])
	b = int(s[2])
	ans = []
	for j in range(n):
		ans.append(0)
	start = 1
	end = n
	(a, b) = (b, a)
	ta = a
	tb = b
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
		continue
	if a >= b:
		i = 1
		while a > 0:
			a -= 1
			ans[i] = start
			start += 1
			i += 2
		i = 2
		while b > 0:
			b -= 1
			ans[i] = end
			end -= 1
			i += 2
	else:
		i = 1
		while b > 0:
			b -= 1
			ans[i] = end
			end -= 1
			i += 2
		i = 2
		while a > 0:
			a -= 1
			ans[i] = start
			start += 1
			i += 2
	for j in range(n):
		if ans[j] == 0:
			if ta > tb:
				ans[j] = start
				start += 1
			else:
				ans[j] = end
				end -= 1
	for j in range(n):
		print(ans[j], end=' ')
	print()


for _ in range(int(input())):
	(n, a, b) = [int(i) for i in input().split()]
	p = [i for i in range(1, n + 1)]
	if a + b + 2 > n or abs(a - b) > 1:
		print(-1)
		continue
	if b > a:
		p = [n - i + 1 for i in p]
	for i in range(1, min(a, b) * 2 + 1, 2):
		(p[i], p[i + 1]) = (p[i + 1], p[i])
	if a != b:
		(p[-2], p[-1]) = (p[-1], p[-2])
	print(' '.join([str(i) for i in p]))


problem_num = int(input())
for i in range(problem_num):
	arr = list(map(int, input().split()))
	if abs(arr[1] - arr[2]) >= 2 or arr[1] + arr[2] > arr[0] - 2:
		print(-1)
		continue
	init = 0
	lst = [init]
	if arr[1] > arr[2]:
		for j in range(arr[1]):
			lst.append(init + j + 1)
			lst.append(init - j - 1)
		for j in range(arr[0] - arr[1] - arr[2] - 2):
			lst.append(init - j - arr[1] - 1)
	if arr[1] < arr[2]:
		for j in range(arr[2]):
			lst.append(init - j - 1)
			lst.append(init + j + 1)
		for j in range(arr[0] - arr[1] - arr[2] - 2):
			lst.append(init + j + arr[2] + 1)
	if arr[1] == arr[2]:
		for j in range(arr[2]):
			lst.append(init + j + 1)
			lst.append(init - j - 1)
		for j in range(arr[0] - arr[1] - arr[2] - 1):
			lst.append(init + j + arr[2] + 1)
	min_val = min(lst)
	lst = [str(i - min_val + 1) for i in lst]
	print(' '.join(lst))


import math
t = int(input())
for tc in range(t):
	(n, mx, mn) = map(int, input().split())
	limit = n - 2
	if mx + mn > limit:
		print(-1)
		continue
	if abs(mx - mn) > 1:
		print(-1)
		continue
	ans = []
	arr1 = None
	arr2 = None
	if n % 2 == 0:
		arr1 = [i for i in range(1, n // 2 + 1)]
		arr2 = [i for i in range(n, n // 2, -1)]
		if mx < mn:
			(arr1, arr2) = (arr2, arr1)
	elif mx >= mn:
		arr1 = [i for i in range(1, n // 2 + 1)]
		arr2 = [i for i in range(n, n // 2, -1)]
	else:
		arr2 = [i for i in range(1, n // 2 + 2)]
		arr1 = [i for i in range(n, n // 2 + 1, -1)]
	cnt = 0
	res = 1
	for i in range(n):
		if i % 2 == 0:
			try:
				ans.append(arr1.pop(0))
			except:
				res = 0
				break
		else:
			try:
				ans.append(arr2.pop(0))
			except:
				res = 0
				break
		if i != 0 and i % 2 == 0:
			cnt += 1
		if cnt == min(mn, mx):
			if mx < mn:
				rmx = 1
				rmn = mn - mx
			else:
				rmx = mx - mn
				rmn = 1
			break
	if res == 0:
		print(-1)
		continue
	if mx == mn:
		ans = ans + sorted(arr1 + arr2)
	else:
		ans = ans + arr1 + arr2
	cmn = 0
	cmx = 0
	for i in range(1, n - 1):
		if ans[i] > ans[i - 1] and ans[i] > ans[i + 1]:
			cmx += 1
		if ans[i] < ans[i - 1] and ans[i] < ans[i + 1]:
			cmn += 1
	if cmx == mx and cmn == mn:
		print(*ans)
	else:
		print(-1)


import os
import sys
from io import BytesIO, IOBase
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	(x, y) = (a, b)
	ans = [0] * n
	if a == b:
		end = n
		for i in range(1, n - 1, 2):
			if a == 0:
				break
			a -= 1
			ans[i] = end
			end -= 1
		start = 1
		for i in range(2, n - 1, 2):
			if b == 0:
				break
			b -= 1
			ans[i] = start
			start += 1
		for i in range(n):
			if ans[i] == 0:
				ans[i] = start
				start += 1
	elif a > b:
		if a - b > 1:
			print(-1)
			continue
		else:
			end = n
			for i in range(1, n - 1, 2):
				if a == 0:
					break
				a -= 1
				ans[i] = end
				end -= 1
			for i in range(n):
				if ans[i] == 0:
					ans[i] = end
					end -= 1
	elif b - a > 1:
		print(-1)
		continue
	else:
		start = 1
		for i in range(1, n - 1, 2):
			if b == 0:
				break
			b -= 1
			ans[i] = start
			start += 1
		for i in range(n):
			if ans[i] == 0:
				ans[i] = start
				start += 1
	a = 0
	b = 0
	for i in range(1, 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
	if a != x:
		print(-1)
	elif b != y:
		print(-1)
	elif len(set(ans)) != n:
		print(-1)
	else:
		print(*ans)


import math
from collections import *

def solve():
	(n, a, b) = map(int, input().split())
	ans = []
	if a + b > n - 2:
		print(-1)
		return
	elif abs(a - b) > 1:
		print(-1)
		return
	else:
		t = n - (a + b + 2)
		for i in range(1, t + 1):
			ans.append(i)
		(s, l) = (t + 1, n)
		for i in range(0, n - t):
			if i % 2 == 0:
				ans.append(s)
				s += 1
			else:
				ans.append(l)
				l -= 1
	if b > a:
		for i in range(len(ans)):
			ans[i] = n - ans[i] + 1
	print(*ans)
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1:
		print(-1)
		continue
	if a + b > n - 2:
		print(-1)
		continue
	p = [None] * n
	lo = 1
	hi = n
	if a > b:
		pos_a = 1
		pos_b = 2
		decreasing = True
	elif a < b:
		pos_b = 1
		pos_a = 2
		decreasing = False
	else:
		pos_a = 1
		pos_b = 2
		decreasing = False
	a_ = a
	while a > 0:
		p[pos_a] = hi
		hi -= 1
		a -= 1
		pos_a += 2
	b_ = b
	while b > 0:
		p[pos_b] = lo
		lo += 1
		b -= 1
		pos_b += 2
	p[0] = lo
	lo += 1
	if decreasing:
		for (delta, j) in enumerate(range(hi, lo - 1, -1), 1):
			p[a_ + b_ + delta] = j
	else:
		for (delta, j) in enumerate(range(lo, hi + 1), 1):
			p[a_ + b_ + delta] = j
	print(' '.join(map(str, p)))


def swaps(arr, i, a):
	n = len(arr)
	while i + 1 < n:
		(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
		a -= 1
		if a == 0:
			break
		i += 2
	return arr
for i in range(int(input())):
	(n, a, b) = list(map(int, input().split()))
	arr = [i for i in range(1, n + 1)]
	done = 0
	if a == 0 and b == 0:
		print(*arr)
		done = 1
	elif abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		done = 1
	elif max(a, b) > n // 2 + n % 2:
		print(-1)
		done = 0
	if done == 0:
		if a > b:
			arr.reverse()
			arr = swaps(arr, 0, a)
		elif a < b:
			arr = swaps(arr, 0, b)
		else:
			arr = swaps(arr, 1, b)
		print(*arr)


import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()

def get_int():
	return int(sys.stdin.readline().strip())

def get_list_strings():
	return list(map(str, sys.stdin.readline().strip().split()))

def solve():
	(n, a, b) = get_ints()
	if a == 0 and b == 0:
		final = [i for i in range(1, n + 1)]
		print(*final)
		return
	if abs(a - b) >= 2:
		print(-1)
		return
	if n <= 2 * a:
		print(-1)
		return
	if n <= 2 * b:
		print(-1)
		return
	final = []
	if a >= b:
		final.append(1)
		current = n
		limit = n - a + 1
		track = 2
		while current >= limit:
			final.append(current)
			final.append(track)
			track += 1
			current -= 1
		if a == b:
			for i in range(track, current + 1):
				final.append(i)
		else:
			final[-1] = current
			track -= 1
			current -= 1
			for i in range(current, track - 1, -1):
				final.append(i)
	else:
		current = 1
		limit = b
		final.append(n)
		track = n - 1
		while current <= limit:
			final.append(current)
			final.append(track)
			current += 1
			track -= 1
		final[-1] = current
		current += 1
		track += 1
		for i in range(current, track + 1):
			final.append(i)
	if len(final) != n:
		print(-1)
		return
	A = 0
	B = 0
	for i in range(1, n - 1):
		if final[i] > final[i - 1] and final[i] > final[i + 1]:
			A += 1
		if final[i] < final[i - 1] and final[i] < final[i + 1]:
			B += 1
	if A == a and B == b:
		print(*final)
		return
	print(-1)
T = get_int()
while T:
	solve()
	T -= 1


def solve(n, a, b):
	if abs(a - b) > 1 or a + b > n - 2:
		return [-1]
	res = [i for i in range(1, n + 1)]
	if a == b:
		i = 2
		while a:
			a -= 1
			(res[i], res[i - 1]) = (res[i - 1], res[i])
			i += 2
	elif b > a:
		i = 1
		while b:
			b -= 1
			(res[i], res[i - 1]) = (res[i - 1], res[i])
			i += 2
	else:
		i = n - 1
		while a:
			a -= 1
			(res[i], res[i - 1]) = (res[i - 1], res[i])
			i -= 2
	return res
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	print(*solve(n, a, b))


import math
t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(*[-1])
		continue
	elif a == b == 0:
		print(*[i for i in range(1, n + 1)])
		continue
	lst = []
	max_a = 0
	min_b = 0
	if a < b:
		lst.append(n)
		lst.append(1)
		cur = 2
		while min_b != b - 1:
			lst.append(n - cur + 1)
			lst.append(cur)
			cur += 1
			min_b += 1
		for i in range(cur, n - cur + 1 + 1):
			lst.append(i)
	elif a > b:
		lst.append(1)
		lst.append(n)
		cur = 2
		while max_a != a - 1:
			lst.append(cur)
			lst.append(n - cur + 1)
			cur += 1
			max_a += 1
		for i in range(n - cur + 1, cur - 1, -1):
			lst.append(i)
	else:
		lst.append(1)
		lst.append(n)
		cur = 2
		fl = True
		while min_b != b:
			if fl:
				lst.append(cur)
				min_b += 1
				fl = False
			else:
				lst.append(n - cur + 1)
				fl = True
			if fl == True:
				cur += 1
		cur += 1
		for i in range(cur, n - cur + 1 + 1 + 1):
			lst.append(i)
	print(*lst)


import sys
T = int(sys.stdin.readline().strip())
for t in range(T):
	(n, a, b) = list(map(int, sys.stdin.readline().strip().split()))
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		ans = [-1] * n
		if a > b:
			i = 1
			c = 1
			j = 0
		elif a == b:
			i = 1
			c = -1
			j = n - 1
		else:
			a = a + 1
			i = 0
			c = -1
			j = n - 1
		while a > 0:
			ans[i] = n
			n = n - 1
			a = a - 1
			i = i + 2
		while n > 0:
			if ans[j] == -1:
				ans[j] = n
				n = n - 1
			j = j + c
		print(' '.join([str(x) for x in ans]))


def rev(a, l, r):
	while l < r:
		(a[l], a[r]) = (a[r], a[l])
		l += 1
		r -= 1
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	arr = [i + 1 for i in range(n)]
	if a == 0 and b == 0:
		print(*arr)
		continue
	if a == 0:
		rev(arr, 0, n - 1)
		rev(arr, 1, n - 1)
		print(*arr)
		continue
	if b == 0:
		rev(arr, 1, n - 1)
		print(*arr)
		continue
	if a > b:
		i = n - 1
		cnt = a
		while cnt:
			(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
			i -= 2
			cnt -= 1
		print(*arr)
		continue
	if b > a:
		i = 0
		cnt = b
		while cnt:
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			i += 2
			cnt -= 1
		print(*arr)
		continue
	if a == b:
		i = 1
		cnt = a
		while cnt:
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
			i += 2
			cnt -= 1
		print(*arr)
		continue


x = int(input())
for i in range(x):
	(n, a, b) = input().split()
	n = int(n)
	a = int(a)
	b = int(b)
	if n - 2 < a + b:
		print(-1)
	elif abs(a - b) > 1:
		print(-1)
	else:
		ans = []
		for ll in range(1, n + 1):
			ans.append(ll)
		if a < b:
			k = n - 2
			for j in range(a):
				(ans[k], ans[k - 1]) = (ans[k - 1], ans[k])
				k -= 2
			(ans[0], ans[1]) = (ans[1], ans[0])
		elif b < a:
			k = 1
			for j in range(b):
				(ans[k], ans[k + 1]) = (ans[k + 1], ans[k])
				k += 2
			(ans[n - 1], ans[n - 2]) = (ans[n - 2], ans[n - 1])
		else:
			k = 1
			for j in range(b):
				(ans[k], ans[k + 1]) = (ans[k + 1], ans[k])
				k += 2
		for kk in ans:
			print(kk, end=' ')
		print()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(b - a) > 1 or a + b > n - 2:
		print(-1)
	else:
		k = 0
		ans = list(range(1, n + 1))
		if a > b:
			ans = ans[::-1]
		elif a == b:
			k = 1
		for _ in range(max(a, b)):
			(ans[k + 1], ans[k]) = (ans[k], ans[k + 1])
			k = k + 2
		for j in ans:
			print(j, end=' ')
		print()


for i in range(int(input())):
	(n, a, b) = map(int, input().split())
	p = [i for i in range(1, n + 1)]
	if a + b + 2 > n or abs(a - b) > 1:
		print(-1)
		continue
	if b > a:
		p = [n - i + 1 for i in p]
	for i in range(1, min(a, b) * 2 + 1, 2):
		(p[i], p[i + 1]) = (p[i + 1], p[i])
	if a != b:
		(p[-2], p[-1]) = (p[-1], p[-2])
	print(*p)


import sys
import math
from sys import stdin, stdout

def get_ints_in_variables():
	return map(int, sys.stdin.readline().strip().split())

def get_int():
	return int(input())

def get_ints_in_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_list_of_list(n):
	return [list(map(int, sys.stdin.readline().strip().split())) for _ in range(n)]

def get_string():
	return sys.stdin.readline().strip()

def main():
	for _ in range(get_int()):
		(n, a, b) = get_ints_in_variables()
		lb = math.ceil(n / 2) - 1
		ans = [0 for i in range(n + 1)]
		if abs(a - b) > 1 or a + b > n - 2:
			print(-1)
		else:
			if a > b:
				cnt = n
				cnt_loop = a
				i = 2
				while i < n + 1 and cnt_loop > 0:
					ans[i] = cnt
					cnt -= 1
					cnt_loop -= 1
					i += 2
				i = 1
				while i < n + 1:
					if ans[i] == 0:
						ans[i] = cnt
						cnt -= 1
					i += 1
			elif b > a:
				cnt = 1
				cnt_loop = b
				i = 2
				while i < n + 1 and cnt_loop > 0:
					ans[i] = cnt
					cnt += 1
					cnt_loop -= 1
					i += 2
				i = 1
				while i < n + 1:
					if ans[i] == 0:
						ans[i] = cnt
						cnt += 1
					i += 1
			else:
				cnt = n
				cnt_loop = a
				i = 2
				while i < n + 1 and cnt_loop > 0:
					ans[i] = cnt
					cnt -= 1
					cnt_loop -= 1
					i += 2
				cnt = 1
				i = 1
				while i < n + 1:
					if ans[i] == 0:
						ans[i] = cnt
						cnt += 1
					i += 1
			for i in range(1, n + 1):
				print(ans[i], end=' ')
			print()
main()


import os, sys
from io import BytesIO, IOBase
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))
try:
	(sys.stdin, sys.stdout) = (open('in.txt', 'r'), open('out.txt', 'w'))
except:
	pass
ii1 = lambda : int(sys.stdin.readline().strip())
is1 = lambda : sys.stdin.readline().strip()
iia = lambda : list(map(int, sys.stdin.readline().strip().split()))
isa = lambda : sys.stdin.readline().strip().split()
mod = int(1000000000.0 + 7)
from math import inf
from collections import defaultdict as dd, deque

def main(t):
	(n, a, b) = iia()
	if abs(a - b) > 1 or a + b + 2 > n:
		print(-1)
		return
	dq = deque(list(range(1, n + 1)))
	if a < b:
		(a, b) = (b, a)
		dq.reverse()
	flag = 1
	ans = []
	for i in range(n):
		if a:
			if flag:
				ans.append(dq.popleft())
			else:
				ans.append(dq.pop())
			a -= 1
			(a, b) = (b, a)
			flag ^= 1
	if not flag:
		dq.reverse()
	if dq:
		ans.extend(list(dq))
	print(*ans)
t = 1
t = ii1()
for _ in range(t):
	main(_)


import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
from collections import Counter
import threading
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class SegmentTree:

	def __init__(self, data, default=10 ** 18, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree1:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
MOD = 10 ** 9 + 7

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
prime = [True for i in range(10001)]
prime[0] = prime[1] = False

def SieveOfEratosthenes(n=10000):
	p = 2
	c = 0
	while p <= n:
		if prime[p] == True:
			c += 1
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1

class DSU:

	def __init__(self, R, C):
		self.par = range(R * C + 1)
		self.rnk = [0] * (R * C + 1)
		self.sz = [1] * (R * C + 1)

	def find(self, x):
		if self.par[x] != x:
			self.par[x] = self.find(self.par[x])
		return self.par[x]

	def union(self, x, y):
		(xr, yr) = (self.find(x), self.find(y))
		if xr == yr:
			return
		if self.rnk[xr] < self.rnk[yr]:
			(xr, yr) = (yr, xr)
		if self.rnk[xr] == self.rnk[yr]:
			self.rnk[xr] += 1
		self.par[yr] = xr
		self.sz[xr] += self.sz[yr]

	def size(self, x):
		return self.sz[self.find(x)]

	def top(self):
		return self.size(len(self.sz) - 1) - 1

class LazySegTree:

	def __init__(self, _op, _e, _mapping, _composition, _id, v):

		def set(p, x):
			assert 0 <= p < _n
			p += _size
			for i in range(_log, 0, -1):
				_push(p >> i)
			_d[p] = x
			for i in range(1, _log + 1):
				_update(p >> i)

		def get(p):
			assert 0 <= p < _n
			p += _size
			for i in range(_log, 0, -1):
				_push(p >> i)
			return _d[p]

		def prod(l, r):
			assert 0 <= l <= r <= _n
			if l == r:
				return _e
			l += _size
			r += _size
			for i in range(_log, 0, -1):
				if l >> i << i != l:
					_push(l >> i)
				if r >> i << i != r:
					_push(r >> i)
			sml = _e
			smr = _e
			while l < r:
				if l & 1:
					sml = _op(sml, _d[l])
					l += 1
				if r & 1:
					r -= 1
					smr = _op(_d[r], smr)
				l >>= 1
				r >>= 1
			return _op(sml, smr)

		def apply(l, r, f):
			assert 0 <= l <= r <= _n
			if l == r:
				return
			l += _size
			r += _size
			for i in range(_log, 0, -1):
				if l >> i << i != l:
					_push(l >> i)
				if r >> i << i != r:
					_push(r - 1 >> i)
			l2 = l
			r2 = r
			while l < r:
				if l & 1:
					_all_apply(l, f)
					l += 1
				if r & 1:
					r -= 1
					_all_apply(r, f)
				l >>= 1
				r >>= 1
			l = l2
			r = r2
			for i in range(1, _log + 1):
				if l >> i << i != l:
					_update(l >> i)
				if r >> i << i != r:
					_update(r - 1 >> i)

		def _update(k):
			_d[k] = _op(_d[2 * k], _d[2 * k + 1])

		def _all_apply(k, f):
			_d[k] = _mapping(f, _d[k])
			if k < _size:
				_lz[k] = _composition(f, _lz[k])

		def _push(k):
			_all_apply(2 * k, _lz[k])
			_all_apply(2 * k + 1, _lz[k])
			_lz[k] = _id
		_n = len(v)
		_log = _n.bit_length()
		_size = 1 << _log
		_d = [_e] * (2 * _size)
		_lz = [_id] * _size
		for i in range(_n):
			_d[_size + i] = v[i]
		for i in range(_size - 1, 0, -1):
			_update(i)
		self.set = set
		self.get = get
		self.prod = prod
		self.apply = apply
MIL = 1 << 20

def makeNode(total, count):
	return total * MIL + count

def getTotal(node):
	return math.floor(node / MIL)

def getCount(node):
	return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)

def nodeOp(node1, node2):
	return node1 + node2
	return makeNode(getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2))
identityMapping = -1

def mapping(tag, node):
	if tag == identityMapping:
		return node
	count = getCount(node)
	return makeNode(tag * count, count)

def composition(mapping1, mapping2):
	return mapping1 if mapping1 != identityMapping else mapping2

class LazySegUpdate:

	def __init__(self, N):
		self.N = N
		n = 4 * N
		self.tree = [0] * n
		self.lazy = [0] * n

	def queryHelper(self, index, s, e, l, r):
		if self.lazy[index]:
			update = self.lazy[index]
			self.lazy[index] = 0
			self.tree[index] = max(self.tree[index], update)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], update)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], update)
		if s > e or s > r or e < l:
			return 0
		if s >= l and e <= r:
			return self.tree[index]
		mid = (s + e) // 2
		return max(self.queryHelper(2 * index, s, mid, l, r), self.queryHelper(2 * index + 1, mid + 1, e, l, r))

	def updateHelper(self, index, s, e, l, r, h):
		if self.lazy[index]:
			update = self.lazy[index]
			self.lazy[index] = 0
			self.tree[index] = max(self.tree[index], update)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], update)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], update)
		if s > e or s > r or e < l:
			return
		if s >= l and e <= r:
			self.tree[index] = max(self.tree[index], h)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], h)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], h)
			return
		mid = (s + e) // 2
		self.updateHelper(2 * index, s, mid, l, r, h)
		self.updateHelper(2 * index + 1, mid + 1, e, l, r, h)
		self.tree[index] = max(self.tree[2 * index], self.tree[2 * index + 1])

	def query(self, l, r):
		return self.queryHelper(1, 0, self.N - 1, l, r - 1)

	def update(self, l, r, h):
		self.updateHelper(1, 0, self.N - 1, l, r - 1, h)

def memodict(f):

	class memodict(dict):

		def __missing__(self, key):
			ret = self[key] = f(key)
			return ret
	return memodict().__getitem__

def pollard_rho(n):
	if n & 1 == 0:
		return 2
	if n % 3 == 0:
		return 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			prev = p
			p = p * p % n
			if p == 1:
				return math.gcd(prev - 1, n)
			if p == n - 1:
				break
		else:
			for i in range(2, n):
				(x, y) = (i, (i * i + 1) % n)
				f = math.gcd(abs(x - y), n)
				while f == 1:
					(x, y) = ((x * x + 1) % n, (y * y + 1) % n)
					y = (y * y + 1) % n
					f = math.gcd(abs(x - y), n)
				if f != n:
					return f
	return n

@memodict
def prime_factors(n):
	if n <= 1:
		return Counter()
	f = pollard_rho(n)
	return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)

def distinct_factors(n):
	factors = [1]
	for (p, exp) in prime_factors(n).items():
		factors += [p ** i * factor for factor in factors for i in range(1, exp + 1)]
	return factors

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

def binarySearch(arr, n, key):
	left = 0
	right = n - 1
	mid = 0
	res = n
	while left <= right:
		mid = (right + left) // 2
		if arr[mid] >= key:
			res = mid
			right = mid - 1
		else:
			left = mid + 1
	return res

def binarySearch1(arr, n, key):
	left = 0
	right = n - 1
	mid = 0
	res = -1
	while left <= right:
		mid = (right + left) // 2
		if arr[mid] > key:
			right = mid - 1
		else:
			res = mid
			left = mid + 1
	return res
for ik in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1:
		print(-1)
		continue
	elif a + b > n - 2:
		print(-1)
		continue
	ans = [0] * n
	if a == b:
		t = n
		for i in range(1, n, 2):
			if a > 0:
				ans[i] = t
				a -= 1
			else:
				break
			t -= 1
		t = 1
		for i in range(n):
			if ans[i] == 0:
				ans[i] = t
				t += 1
	elif a > b:
		t = n
		for i in range(1, n, 2):
			if a > 0:
				ans[i] = t
				a -= 1
			else:
				break
			t -= 1
		for i in range(n):
			if ans[i] == 0:
				ans[i] = t
				t -= 1
	else:
		t = 1
		for i in range(1, n, 2):
			if b > 0:
				ans[i] = t
				b -= 1
			else:
				break
			t += 1
		for i in range(n):
			if ans[i] == 0:
				ans[i] = t
				t += 1
	print(*ans)


import sys
input = sys.stdin.readline
tests = int(input())
for _ in range(tests):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b + 2 > n:
		print(-1)
		continue
	nums = list(range(1, n + 1))
	if a > b:
		(nums[-2], nums[-1]) = (nums[-1], nums[-2])
	elif b > a:
		(nums[0], nums[1]) = (nums[1], nums[0])
		nums = nums[::-1]
	for i in range(min(a, b)):
		(nums[2 * i + 1], nums[2 * i + 2]) = (nums[2 * i + 2], nums[2 * i + 1])
	print(*nums)


t = int(input())

def solve():
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		return
	c = 0
	d = n - 1
	if a >= b:
		out = [c]
		c += 1
		while a or b:
			if a > 0:
				out.append(d)
				a -= 1
				d -= 1
			if b > 0:
				out.append(c)
				b -= 1
				c += 1
	else:
		out = [d]
		d -= 1
		while a or b:
			if b > 0:
				out.append(c)
				b -= 1
				c += 1
			if a > 0:
				out.append(d)
				a -= 1
				d -= 1
	if out[-1] == c - 1:
		out += range(c, d + 1)
	else:
		out += range(d, c - 1, -1)
	out = [x + 1 for x in out]
	print(*out)
	return
for _ in range(t):
	solve()


import bisect
import collections
import itertools
import sys
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()

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])
			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))
	elif 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])
		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():
	for _ in range(II()):
		sys.stdout.write(str(solve()) + '\n')
main()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1:
		print(-1)
		continue
	if max(a, b) > n - 1 >> 1:
		print(-1)
		continue
	if (a == b and a == (n - 1) // 2) and n & 1:
		print(-1)
		continue
	minn = min(a, b)
	if minn == b:
		l = [1]
		i = n
		k = 2
		for _ in range(minn):
			l.append(i)
			l.append(k)
			i = i - 1
			k = k + 1
		if a == b:
			for _ in range(n - len(l)):
				l.append(k)
				k = k + 1
		else:
			for _ in range(n - len(l)):
				l.append(i)
				i = i - 1
		print(*l)
		continue
	if minn == a:
		l = [n]
		i = n - 1
		k = 1
		for _ in range(minn):
			l.append(k)
			l.append(i)
			k = k + 1
			i = i - 1
		for _ in range(max(b - a, n - len(l))):
			l.append(k)
			k = k + 1
		print(*l)


kl = int(input())
for kkl in range(kl):
	(n, a, b) = map(int, input().split())
	if a <= (n - 1) // 2 and b == a - 1:
		sp = list((n - i for i in range(n)))
		for i in range(a):
			(sp[2 * i], sp[2 * i + 1]) = (sp[2 * i + 1], sp[2 * i])
		print(*sp)
	elif a == b and a + b <= n - 2:
		sp = list((i + 1 for i in range(n)))
		for i in range(a):
			(sp[2 * i + 1], sp[2 * i + 2]) = (sp[2 * i + 2], sp[2 * i + 1])
		print(*sp)
	elif b <= (n - 1) // 2 and b == a + 1:
		sp = list((i + 1 for i in range(n)))
		for i in range(b):
			(sp[2 * i], sp[2 * i + 1]) = (sp[2 * i + 1], sp[2 * i])
		print(*sp)
	else:
		print(-1)


from collections import deque

def solution(n, a, b):
	limit = (n - 1) // 2
	if a > limit or b > limit or a + b > 2 * limit - n % 2 or (abs(a - b) > 1):
		return [-1]
		_hy_anon_var_1 = None
	else:
		_hy_anon_var_1 = None
	rst = [1]
	nums = deque(range(2, n + 1))
	M = max(a, b)
	m = min(a, b)
	for _ in range(m):
		rst.append(nums.pop())
		rst.append(nums.popleft())
	if M > m:
		while nums:
			rst.append(nums.pop())
		_hy_anon_var_2 = None
	else:
		while nums:
			rst.append(nums.popleft())
		_hy_anon_var_2 = None
	return rst if a >= b else [n + 1 - i for i in rst]
t = int(input())
for _ in range(t):
	[n, a, b] = list(map(int, input().split()))
	print(' '.join(map(str, solution(n, a, b))))


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	(l, r) = (1, n)
	ans = []
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	elif a == b:
		(h, v) = (0, 0)
		ans.append(l)
		l += 1
		while h < a:
			ans.append(r)
			r -= 1
			ans.append(l)
			l += 1
			h += 1
		for i in range(l, r + 1):
			ans.append(i)
	elif a > b:
		h = 0
		ans.append(l)
		l += 1
		while h < a - 1:
			ans.append(r)
			r -= 1
			ans.append(l)
			l += 1
			h += 1
		i = r
		while i >= l:
			ans.append(i)
			i -= 1
	else:
		v = 0
		ans.append(r)
		r -= 1
		while v < b - 1:
			ans.append(l)
			l += 1
			ans.append(r)
			r -= 1
			v += 1
		for i in range(l, r + 1):
			ans.append(i)
	print(*ans)


def buildPermutation(n, a, b):
	array = [x for x in range(1, n + 1)]
	if abs(a - b) > 1:
		return [-1]
	if a == b:
		if (n - 2) // 2 < a:
			return [-1]
		for x in range(a):
			(array[2 * (x + 1) - 1], array[2 * (x + 1)]) = (array[2 * (x + 1)], array[2 * (x + 1) - 1])
		return array
	else:
		if (n - 3) // 2 < min(a, b):
			return [-1]
		if a > b:
			(array[0], array[1]) = (array[1], array[0])
			a -= 1
			for x in range(a):
				(array[2 * (x + 1)], array[2 * (x + 1) + 1]) = (array[2 * (x + 1) + 1], array[2 * (x + 1)])
		else:
			(array[-1], array[-2]) = (array[-2], array[-1])
			b -= 1
			for x in range(b):
				(array[2 * (x + 1) - 1], array[2 * (x + 1)]) = (array[2 * (x + 1)], array[2 * (x + 1) - 1])
		return array
t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	ans = buildPermutation(n, b, a)
	for x in ans:
		print(x, end=' ')
	print()


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, a, b) = map(int, stdin.readline().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		arr = [i + 1 for i in range(n)]
		ans = []
		if a == b:
			i = 0
			j = a + 1
			while i <= b:
				ans.append(arr[i])
				ans.append(arr[j])
				i += 1
				j += 1
			while j < n:
				ans.append(arr[j])
				j += 1
		elif a > b:
			i = 0
			j = a
			while i < a - 1:
				ans.append(arr[i])
				ans.append(arr[j])
				i += 1
				j += 1
			ans.append(arr[i])
			ans.append(arr[-1])
			jj = n - 2
			while j <= jj:
				ans.append(arr[jj])
				jj -= 1
		else:
			i = a + 1
			j = 0
			while j <= a:
				ans.append(arr[i])
				ans.append(arr[j])
				i += 1
				j += 1
			while i < n:
				ans.append(arr[i])
				i += 1
		print(*ans)


test = int(input())
for _ in range(test):
	(n, a, b) = map(int, input().split())
	alist = list(range(1, n + 1))
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	if a == b:
		i = 1
	elif a > b:
		i = 0
		alist = alist[::-1]
	elif b > a:
		i = 0
	count = max(a, b)
	while count > 0:
		alist.insert(i, alist[-1])
		del alist[-1]
		count -= 1
		i += 2
	print(*alist)


t = int(input())
for i in range(t):
	(n, a, b) = input().split()
	n = int(n)
	a = int(a)
	b = int(b)
	l = []
	kaf = int((n - 1) / 2)
	if a > kaf or b > kaf or a - b > 1 or (b - a > 1) or (a + b > n - 2):
		print(-1)
	elif a > b:
		i = 0
		p = 1
		l.append(p)
		p += 1
		q = n
		while i < b:
			l.append(q)
			q -= 1
			l.append(p)
			p += 1
			i += 1
		while q >= p:
			l.append(q)
			q -= 1
	elif a < b:
		i = 0
		p = 1
		q = n
		l.append(q)
		q -= 1
		while i < a:
			l.append(p)
			p += 1
			l.append(q)
			q -= 1
			i += 1
		while p <= q:
			l.append(p)
			p += 1
	else:
		i = 0
		p = 1
		l.append(p)
		p += 1
		q = n
		while i < b:
			l.append(q)
			q -= 1
			l.append(p)
			p += 1
			i += 1
		while p <= q:
			l.append(p)
			p += 1
	print(*l)


def solve():
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		arr = []
		if a > b:
			l = 1
			r = n
			arr.append(l)
			l += 1
			for i in range(b):
				arr.append(r)
				arr.append(l)
				l += 1
				r -= 1
			while r >= l:
				arr.append(r)
				r -= 1
		elif a < b:
			l = 1
			r = n
			arr.append(r)
			r -= 1
			for i in range(a):
				arr.append(l)
				arr.append(r)
				l += 1
				r -= 1
			while l <= r:
				arr.append(l)
				l += 1
		else:
			l = 1
			r = n
			arr.append(l)
			l += 1
			for i in range(b):
				arr.append(r)
				arr.append(l)
				l += 1
				r -= 1
			while r >= l:
				arr.append(l)
				l += 1
		print(*arr)
t = int(input())
for tc in range(t):
	solve()


for i in range(int(input())):
	(length, maximum, minimum) = map(int, input().split())
	if abs(maximum - minimum) >= 2 or maximum + minimum > length - 2:
		print(-1)
	else:
		if maximum >= minimum:
			array = []
			for i in range(2, length + 1):
				array.append(i)
			print(1, end=' ')
			while minimum > 0:
				print(array[len(array) - 1], end=' ')
				print(array[0], end=' ')
				array.pop(0)
				array.pop(len(array) - 1)
				maximum -= 1
				minimum -= 1
			if maximum > minimum:
				for i in range(len(array) - 1, -1, -1):
					print(array[i], end=' ')
			else:
				for i in range(0, len(array)):
					print(array[i], end=' ')
		else:
			array = []
			for i in range(length - 1, 0, -1):
				array.append(i)
			print(length, end=' ')
			while maximum > 0:
				print(array[len(array) - 1], end=' ')
				print(array[0], end=' ')
				array.pop(0)
				array.pop(len(array) - 1)
				maximum -= 1
				minimum -= 1
			for i in range(len(array) - 1, -1, -1):
				print(array[i], end=' ')
		print('')


import sys
input = sys.stdin.readline
for i in ' ' * int(input()):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	res = []
	if a > b:
		for i in range(b):
			res.append(n - i)
			res.append(i + 1)
		res.append(n - b)
		not_used = [b + 1, n - b]
	elif a == b:
		for i in range(b):
			res.append(n - i)
			res.append(i + 1)
		not_used = [b + 1, n - b + 1]
	else:
		for i in range(a):
			res.append(i + 1)
			res.append(n - i)
		res.append(a + 1)
		not_used = [a + 2, n - a + 1]
	(l, r) = not_used
	for i in range(l, r):
		if i == l:
			res = [i] + res
		elif a > b:
			res.append(l + r - i)
		else:
			res.append(i)
	for i in res:
		print(i, end=' ')
	print()


from collections import deque
t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	if a + b + 2 > n:
		print(-1)
		continue
	if abs(a - b) > 1:
		print(-1)
		continue
	q = deque(range(n - a - b - 1, n + 1))
	ans = []
	cnt = 0
	while q:
		if cnt % 2 == 0:
			x = q.popleft()
			ans.append(x)
		else:
			x = q.pop()
			ans.append(x)
		cnt += 1
	ans = list(range(1, n - a - b - 1)) + ans
	if a < b:
		ans = [n + 1 - i for i in ans]
	print(*ans)


from sys import stdin, stdout
t = int(stdin.readline())
for tt in range(t):
	(n, a, b) = [int(s) for s in stdin.readline().split()]
	if abs(a - b) > 1 or a + b > n - 2:
		stdout.write('-1\n')
		continue
	ar = [i for i in range(n + 1)]
	if a >= b:
		li = n
		if a > 0:
			(ar[li], ar[li - 1]) = (ar[li - 1], ar[li])
			a -= 1
			li -= 2
		while a > 0:
			(ar[li], ar[li - 1]) = (ar[li - 1], ar[li])
			a -= 1
			b -= 1
			li -= 2
		if b != 0:
			(ar[1], ar[2]) = (ar[2], ar[1])
	else:
		fi = 1
		if b > 0:
			(ar[fi], ar[fi + 1]) = (ar[fi + 1], ar[fi])
			b -= 1
			fi += 2
		while b > 0:
			(ar[fi], ar[fi + 1]) = (ar[fi + 1], ar[fi])
			b -= 1
			a -= 1
			fi += 2
		if a != 0:
			(ar[n - 1], ar[n]) = (ar[n], ar[n - 1])
	stdout.write(' '.join([str(s) for s in ar[1:]]) + '\n')


from sys import stdout, stdin
from io import IOBase, BytesIO
from os import read, supports_follow_symlinks, write, fstat
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 = read(self._fd, max(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, size: int=...):
		while self.newlines == 0:
			b = read(self._fd, max(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:
			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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))

def input():
	return stdin.readline().rstrip('\r\n')

def unioun_max_min(arr1, arr2):
	len1 = len(arr1)
	len2 = len(arr2)
	result = []
	if len1 > len2:
		for i in range(len2):
			result.append(arr1[i])
			result.append(arr2[i])
		result.append(arr1[len1 - 1])
	elif len1 == len2:
		for i in range(len2):
			result.append(arr1[i])
			result.append(arr2[i])
	else:
		for i in range(len1):
			result.append(arr2[i])
			result.append(arr1[i])
		result.append(arr2[len2 - 1])
	return result

def main():
	t = int(input())
	for _ in ' ' * t:
		(n, a, b) = map(int, input().split())
		if abs(a - b) >= 2 or a + b > n - 2:
			print(-1)
			continue
		init_arr = list(range(1, n + 1))
		if a == 0:
			max_arr = []
		else:
			max_arr = init_arr[-a:]
		min_arr = init_arr[:b]
		middle_arr = init_arr[b:n - a]
		final_middle_arr = unioun_max_min(min_arr, max_arr)
		result = [middle_arr[0]] + final_middle_arr
		if a >= b:
			result = result + middle_arr[1:][::-1]
		else:
			result = result + middle_arr[1:]
		if len(result) != n:
			result = result[:-1]
		if a == 0 and b == 0:
			print(*init_arr)
			continue
		print(*result)
main()


from itertools import zip_longest
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	ans = []
	m = max(a, b)
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	need = 2 * m + 1
	if a == b:
		for i in range(1, a + 2):
			ans += [i, i + a + 1]
		ans += list(range(2 * (a + 1) + 1, n + 1))
	elif a > b:
		ans += [1, m + 2, 2]
		for i in range(3, 3 + a - 1):
			ans += [i + a, i]
		ans = ans[:-1] + list(range(need + 1, n + 1)) + [ans[-1]]
	else:
		ans += [1 + b, 1, 2 + b]
		for i in range(2, 2 + b - 1):
			ans += [i, i + b + 1]
		ans += list(range(need + 1, n + 1))
	print(' '.join(map(str, ans)))


def solve(n, a, b):
	if a > (n - 1) // 2:
		return [-1]
	if b > (n - 1) // 2:
		return [-1]
	if a + b > n - 2:
		return [-1]
	if abs(a - b) > 1:
		return [-1]
	flagreverse = 0
	if a > b:
		flagreverse = 1
		(a, b) = (b, a)
	l = []
	for i in range(b * 2):
		if i % 2 == 0:
			l.append(n - i // 2)
		else:
			l.append((i + 1) // 2)
	if a == b:
		i = n - b
		while len(l) < n:
			l.append(i)
			i -= 1
	else:
		i = b + 1
		while len(l) < n:
			l.append(i)
			i += 1
	if flagreverse != 0:
		for i in range(len(l)):
			l[i] = n + 1 - l[i]
	return l
n = int(input())
for i in range(n):
	(n, a, b) = list(map(int, input().split()))
	print(*solve(n, a, b))


for _ in range(int(input())):
	l = [int(i) for i in input().split()]
	n = l[0]
	a = l[1]
	b = l[2]
	if n == 2 and (a != 0 or b != 0):
		print(-1)
		continue
	if abs(a - b) > 1:
		print(-1)
		continue
	if n - (a + b) < 2:
		print(-1)
		continue
	res = []
	ad = []
	i = 1
	if a > b:
		while a > 0:
			res += [i]
			i += 1
			res += [n]
			n -= 1
			a -= 1
		res += [i for i in range(n, i - 1, -1)]
		print(*res, sep=' ')
		continue
	if b > a:
		while b > 0:
			res += [n]
			n -= 1
			res += [i]
			i += 1
			b -= 1
		res += [i for i in range(i, n + 1)]
		print(*res, sep=' ')
		continue
	while a > 0:
		res += [i]
		i += 1
		res += [n]
		n -= 1
		a -= 1
	k = [i for i in range(i, n + 1)]
	res = res + k
	print(*res, sep=' ')


import sys
inpu = sys.stdin.readline
prin = sys.stdout.write
t = int(inpu())
for _ in range(t):
	(n, a, b) = map(int, inpu().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	out = []
	if a == b:
		for i in range(a):
			out.append(i + 1)
			out.append(i + a + 2)
		out.append(a + 1)
		while len(out) < n:
			out.append(len(out) + 1)
	elif a < b:
		for i in range(b):
			out.append(i + b + 1)
			out.append(i + 1)
		while len(out) < n:
			out.append(len(out) + 1)
	else:
		for i in range(b):
			out.append(i + 1)
			out.append(i + b + 2)
		out.append(b + 1)
		out.append(n)
		while len(out) < n:
			out.append(out[-1] - 1)
	print(' '.join((str(guy) for guy in out)))


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split(' '))
	arr = []
	if a + b + 2 > n or a > (n - 1) // 2 or b > (n - 1) // 2:
		print(-1)
	elif abs(b - a) > 1:
		print(-1)
	else:
		if a > b:
			for num in range(1, (a + b) // 2 + 2):
				arr.append(num)
				arr.append(n - num + 1)
			for _ in range(n - a, a, -1):
				arr.append(_)
		elif b > a:
			for num in range(1, (a + b) // 2 + 2):
				arr.append(n - num + 1)
				arr.append(num)
			for _ in range(b + 1, n - b + 1):
				arr.append(_)
		else:
			for num in range(1, (a + b) // 2 + 1):
				arr.append(n - num + 1)
				arr.append(num)
			for _ in range(n - a, a, -1):
				if len(arr) < n:
					arr.append(_)
				else:
					break
		print(*arr)


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
inp = lambda : list(map(int, sys.stdin.readline().rstrip('\r\n').split()))
Mod = 998244353
for _ in range(int(input())):
	(n, b, a) = map(int, input().split())
	if a + b <= n - 2:
		if abs(a - b) <= 1:
			l = []
			h = []
			ans = []
			if a == b:
				j = 2
				ans = [1]
				for _ in range(a):
					l.append(j)
					j += 1
				for _ in range(b):
					h.append(j)
					j += 1
				for i in range(a):
					ans.append(h[i])
					ans.append(l[i])
				for i in range(j, n + 1):
					ans.append(i)
				print(*ans)
			elif a < b:
				ans = [1]
				j = 3
				for _ in range(a):
					l.append(j)
					j += 1
				for _ in range(a):
					h.append(j)
					j += 1
				for i in range(a):
					ans.append(h[i])
					ans.append(l[i])
				for i in range(j, n + 1):
					ans.append(i)
				ans.append(2)
				print(*ans)
			else:
				j = 2
				ans = [n]
				for _ in range(b):
					l.append(j)
					j += 1
				for _ in range(b):
					h.append(j)
					j += 1
				for i in range(b):
					ans.append(l[i])
					ans.append(h[i])
				ans.append(1)
				for i in range(j, n):
					ans.append(i)
				print(*ans)
			continue
	print(-1)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if a + b + 2 <= n and abs(a - b) <= 1:
		ans = []
		for i in range(1, max(a, b) * 2 + 3):
			ans.append(i % 2)
		for i in range(1, max(a, b) * 2 + 3, 2):
			ans[i - 1] += i
			ans[i] += i
		if a < b:
			ans = ans[:len(ans) - 2] + ans[len(ans) - 2:][::-1]
			ans = ans[:n]
		elif b < a:
			ans = ans[:2][::-1] + ans[2:]
			ans = ans[1:]
			ans = [i - 1 for i in ans]
			ans = ans[:n]
		ind = ans.index(max(ans))
		xxx = max(ans)
		x = [i + xxx for i in range(1, n - len(ans) + 1)]
		ans = ans[:ind + 1] + x + ans[ind + 1:]
		if max(a, b) == 0:
			print(*[i for i in range(1, n + 1)])
		else:
			ans = ans[:n]
			print(*ans)
	elif max(a, b) == 0:
		print(*[i for i in range(1, n + 1)])
	else:
		print(-1)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	left = 1
	right = n
	ans = []
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	else:
		if a == b:
			hill = 0
			valley = 0
			ans.append(left)
			left += 1
			while hill < a:
				ans.append(right)
				right -= 1
				ans.append(left)
				left += 1
				hill += 1
			for i in range(left, right + 1):
				ans.append(i)
		elif a > b:
			hill = 0
			ans.append(left)
			left += 1
			while hill < a - 1:
				ans.append(right)
				right -= 1
				ans.append(left)
				left += 1
				hill += 1
			for i in range(right, left - 1, -1):
				ans.append(i)
		else:
			ans.append(right)
			right -= 1
			valley = 0
			while valley < b - 1:
				ans.append(left)
				left += 1
				ans.append(right)
				right -= 1
				valley += 1
			for i in range(left, right + 1):
				ans.append(i)
		print(*ans)


from math import ceil

def perm(l1, a, b):
	perm = []
	for i in range(len(l1)):
		if i % 2 == 0:
			perm.append(l1.pop(0))
		else:
			perm.append(l1.pop())
	return perm
tests = int(input())
for t in range(tests):
	(n, a, b) = list(map(int, input().split()))
	output = ''
	if a == b == 0:
		for i in range(n):
			output += str(i + 1) + ' '
		print(output)
		continue
	if a + b > n - 2:
		print(-1)
		continue
	if abs(a - b) <= 1:
		if a >= b:
			l1 = list(range(n - a - b - 1, n + 1))
			l2 = list(range(1, n - a - b - 1))
			out = perm(l1, a, b)
			p = l2 + out
		else:
			l1 = list(range(n - a - b - 1, n + 1))
			l2 = list(range(1, n - a - b - 1))
			out = perm(l1, b, a)
			p = l2 + out
			for i in range(n):
				p[i] = n - p[i] + 1
		print(' '.join((str(pi) for pi in p)))
		continue
	else:
		print(-1)
		continue


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	if a + b + 2 > n or abs(a - b) >= 2:
		print(-1)
	else:
		l = []
		for j in range(n):
			l.append(j + 1)
		if a < b:
			for j in range(0, 2 * b, 2):
				x = l[j]
				l[j] = l[j + 1]
				l[j + 1] = x
		elif a == b:
			for i in range(1, 2 * a, 2):
				x = l[i]
				l[i] = l[i + 1]
				l[i + 1] = x
		else:
			for j in range(n - 1, n - 2 * a, -2):
				y = l[j]
				l[j] = l[j - 1]
				l[j - 1] = y
		print(*l)


import math
t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	s = []
	if math.fabs(a - b) > 1:
		print(-1)
	elif a * 2 >= n or b * 2 >= n:
		print(-1)
	elif a + b > n - 2:
		print(-1)
	else:
		for k in range(n):
			s.append(k + 1)
		if b > a:
			for k in range(b):
				c = s[1 + k * 2]
				s[1 + k * 2] = s[k * 2]
				s[k * 2] = c
			print(*s)
		if a > b:
			for k in range(a):
				c = s[n - 1 - 2 * k]
				s[n - 1 - 2 * k] = s[n - 2 - 2 * k]
				s[n - 2 - 2 * k] = c
			print(*s)
		if a == b:
			for k in range(a):
				if k == 0:
					c = s[1]
					s[1] = s[0]
					s[0] = c
					c = s[n - 1]
					s[n - 1] = s[n - 2]
					s[n - 2] = c
				else:
					c = s[1 + k * 2]
					s[1 + k * 2] = s[k * 2]
					s[k * 2] = c
			print(*s)


for _ in range(int(input())):
	x = list(map(int, input().split()))
	(n, a, b) = (x[0], x[1], x[2])
	if a == 0 and b == 0:
		print(*[i for i in range(1, n + 1)])
	elif a + b > n - 2:
		print(-1)
	elif abs(a - b) > 1:
		print(-1)
	else:
		ar = [i for i in range(1, n + 1)]
		if a > b:
			i = n - 1
			while a > 0:
				a -= 1
				(ar[i], ar[i - 1]) = (ar[i - 1], ar[i])
				i -= 2
			print(*ar)
		elif b > a:
			i = 0
			while b > 0:
				b -= 1
				(ar[i], ar[i + 1]) = (ar[i + 1], ar[i])
				i += 2
			print(*ar)
		else:
			i = 0
			while b > 0:
				b -= 1
				(ar[i], ar[i + 1]) = (ar[i + 1], ar[i])
				i += 2
			(ar[n - 1], ar[n - 2]) = (ar[n - 2], ar[n - 1])
			print(*ar)


for i in range(int(input())):
	(n, a, b) = map(int, input().split())
	if a + b <= n - 2 and abs(a - b) <= 1:
		ans = []
		if a + b == n - 2 and n % 2 != abs(a - b):
			print(-1)
		else:
			if not abs(a - b):
				l = 1
				r = n
				ans.append(l)
				l += 1
				for i in range(a):
					ans.append(r)
					r -= 1
					ans.append(l)
					l += 1
				for i in range(l, r + 1):
					ans.append(i)
			elif a > b:
				l = 1
				r = n
				ans.append(l)
				l += 1
				for i in range(a - 1):
					ans.append(r)
					r -= 1
					ans.append(l)
					l += 1
				for i in range(r, l - 1, -1):
					ans.append(i)
			else:
				l = 1
				r = n
				ans.append(r)
				r -= 1
				for i in range(b - 1):
					ans.append(l)
					l += 1
					ans.append(r)
					r -= 1
				for i in range(l, r + 1):
					ans.append(i)
			for i in ans:
				print(i, end=' ')
			print()
	else:
		print(-1)


for i in range(int(input())):
	(n, a, b) = map(int, input().split())
	ans = []
	if a + b + 2 > n or abs(a - b) >= 2:
		print('-1')
	else:
		if a > b:
			for j in range(a):
				ans.append(j + 1)
				ans.append(n - j)
			for j in range(n - 2 * a):
				ans.append(n - a - j)
		elif a < b:
			for j in range(b):
				ans.append(n - j)
				ans.append(j + 1)
			for j in range(n - 2 * b):
				ans.append(b + j + 1)
		else:
			for j in range(a):
				ans.append(j + 1)
				ans.append(n - j)
			for j in range(n - 2 * a):
				ans.append(a + j + 1)
		print(*ans)


def createlist(n, a, b):
	if abs(a - b) > 1 or a + b > n - 2:
		return [-1]
	else:
		list1 = [i for i in range(1, n + 1)]
		if a > b:
			list1 = list1[::-1]
			for i in range(0, a + b, 2):
				(list1[i], list1[i + 1]) = (list1[i + 1], list1[i])
		elif a < b:
			for i in range(0, a + b, 2):
				(list1[i], list1[i + 1]) = (list1[i + 1], list1[i])
		else:
			for i in range(1, a + b, 2):
				(list1[i], list1[i + 1]) = (list1[i + 1], list1[i])
		return list1
n1 = int(input())
answer = []
for i in range(n1):
	list1 = list(map(int, input().split()))
	answer.append(createlist(list1[0], list1[1], list1[2]))
for ii in answer:
	for iii in ii:
		print(iii, end=' ')
	print('')


import os
import sys
from math import *
from bisect import *
from io import BytesIO, IOBase
from typing import overload

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = int(1000000000.0 + 7)
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]

def ok(a, x, y):
	for i in range(1, n - 1):
		if a[i] > a[i - 1] and a[i] > a[i + 1]:
			x -= 1
		elif a[i] < a[i - 1] and a[i] < a[i + 1]:
			y -= 1
	return x == 0 and y == 0
for _ in range(Int()):
	(n, a, b) = value()
	ans = []
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		(l, r, i) = (1, n, 0)
		mn = min(a, b)
		if a > b:
			while i < a + b + 2:
				if i % 2 == 0:
					ans.append(l)
					l += 1
				else:
					ans.append(r)
					r -= 1
				i += 1
		else:
			while i < a + b + 2:
				if i % 2 == 0:
					ans.append(r)
					r -= 1
				else:
					ans.append(l)
					l += 1
				i += 1
		extra = [i for i in range(l, r + 1)]
		extra.append(ans.pop(0))
		extra.sort()
		if ans[0] == 1:
			ans = extra[::-1] + ans[:]
		else:
			ans = extra[:] + ans[:]
		if ok(ans, a, b):
			print(*ans)
		else:
			print(-1)


import sys
import pprint
import logging
from logging import getLogger

def input():
	return sys.stdin.readline().rstrip('\r\n')
logging.basicConfig(format='%(message)s', level=logging.WARNING)
logger = getLogger(__name__)
logger.setLevel(logging.INFO)

def debug(msg, *args):
	logger.info(f'{msg}={pprint.pformat(args)}')

def slv():
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b + 2 > n:
		print(-1)
		return
	arr = []
	if a > b:
		for i in range(a):
			arr += [i + 1, n - i]
		for i in range(n - a, a, -1):
			arr.append(i)
	elif b > a:
		se = set()
		for i in range(b):
			arr += [n - i, i + 1]
			se.add(n - i)
			se.add(i + 1)
		for i in range(1, n + 1):
			if i in se:
				continue
			arr.append(i)
	else:
		se = set()
		for i in range(a):
			arr += [i + 1, n - i]
			se.add(i + 1)
			se.add(n - i)
		for i in range(1, n + 1):
			if i in se:
				continue
			arr.append(i)
	print(*arr)
for _ in range(int(input())):
	slv()


for i in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	if abs(b - c) > 1 or b + c + 1 >= a:
		print(-1)
	else:
		d = list(range(1, a + 1))
		if b > c:
			k = a - b - c - 1
			for j in range(a - b - c - 2, a, 2):
				d[j] = k
				k += 1
			for j in range(a - b - c - 1, a - 1, 2):
				d[j] = k
				k += 1
		elif b < c:
			k = b + c + 2
			for j in range(0, b + c + 2, 2):
				d[j] = k
				k -= 1
			for j in range(1, b + c + 1, 2):
				d[j] = k
				k -= 1
		else:
			k = 1
			for j in range(0, b + c + 2, 2):
				d[j] = k
				k += 1
			for j in range(1, b + c + 1, 2):
				d[j] = k
				k += 1
		print(*d)


import sys, os
import math
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
from io import BytesIO, IOBase
from heapq import *
from bisect import *
from collections import *

def main():
	for _ in range(mi()):
		(n, a, b) = MI()
		x = n - 2
		ma = x // 2
		mb = x - ma
		if not (a <= ma and b <= mb or (a <= mb and b <= ma)) or abs(a - b) > 1:
			print(-1)
			continue
		t = (n + 1) // 2
		arr1 = [i for i in range(1, t + 1)]
		arr2 = [i for i in range(n, n - t + n % 2, -1)]
		if a >= b:
			i = 1
			j = 0
			ans = [arr1[0]]
			flag = 1
		else:
			i = 0
			j = 1
			ans = [arr2[0]]
			flag = 0
		while a != 0 or b != 0:
			if flag:
				ans.append(arr2[j])
				j += 1
				a -= 1
			else:
				ans.append(arr1[i])
				i += 1
				b -= 1
			flag ^= 1
		if flag:
			ans += arr1[i:] + arr2[j:][::-1]
		else:
			ans += arr2[j:] + arr1[i:][::-1]
		print(*ans)
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def MI():
	return map(int, input().split())

def mi():
	return int(input())

def outP(var):
	sys.stdout.write(str(var) + '\n')
MOD = 10 ** 9 + 7
mod = 998244353
main()


def input_int():
	return int(input())

def input_multiple():
	return map(int, input().split())
t = input_int()
while t > 0:
	(n, a, b) = input_multiple()
	if abs(a - b) > 1 or a + b > n - 2 or a > n // 2 or (b > n // 2):
		print(-1)
	elif a == b == 0:
		print(*list(range(1, n + 1)))
	else:
		l = 1
		h = n
		x = []
		while len(x) != n:
			if len(x) == 0:
				if a > b:
					x.append(l)
					l += 1
				else:
					x.append(h)
					h -= 1
			elif a > b:
				x.append(h)
				h -= 1
				a -= 1
			elif b > a:
				x.append(l)
				l += 1
				b -= 1
			elif a == b == 0:
				if x[-1] > l:
					x.extend(list(range(h, l - 1, -1)))
				else:
					x.extend(list(range(l, h + 1)))
			elif x[-1] > l:
				x.append(l)
				l += 1
				b -= 1
			else:
				x.append(h)
				h -= 1
				a -= 1
		print(*x)
	t -= 1


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	l = [j + 1 for j in range(n)]
	if abs(a - b) > 1:
		print(-1)
	elif a + b > n - 2:
		print(-1)
	else:
		if a - b == 1:
			for j in range(a):
				(l[-1 - 2 * j], l[-2 - 2 * j]) = (l[-2 - 2 * j], l[-1 - 2 * j])
		elif a == b:
			for j in range(a):
				(l[-2 - 2 * j], l[-3 - 2 * j]) = (l[-3 - 2 * j], l[-2 - 2 * j])
		elif b - a == 1:
			for j in range(b):
				(l[2 * j], l[2 * j + 1]) = (l[2 * j + 1], l[2 * j])
		print(*l)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if a + b + 2 > n or abs(a - b) > 1:
		print(-1)
		continue
	if n == 2 and a == 0 and (b == 0):
		print(1, 2)
		continue
	l = [0] * n
	for i in range(1, n + 1):
		l[i - 1] = i
	if a > b:
		for i in range(n - 1, n - 1 - 2 * a, -2):
			(l[i], l[i - 1]) = (l[i - 1], l[i])
	elif b > a:
		for i in range(0, 2 * b - 1, 2):
			(l[i], l[i + 1]) = (l[i + 1], l[i])
	else:
		for i in range(1, 2 * a, 2):
			(l[i], l[i + 1]) = (l[i + 1], l[i])
	for i in l:
		print(i, end=' ')
	print()


for _ in range(int(input())):
	(n, a, b) = [int(x) for x in input().split()]
	if abs(a - b) > 1 or a + b + 2 > n:
		print(-1)
	else:
		low = [i + 1 for i in range(b)]
		high = [n - i for i in range(a)]
		ans = []
		if a == b:
			ans += [i for i in range(n - a, b + 1, -1)]
			for i in range(a):
				ans.append(low[i])
				ans.append(high[i])
			ans.append(b + 1)
		elif a > b:
			ans += [i for i in range(b + 1, n - a)]
			ans.append(high[0])
			for i in range(b):
				ans.append(low[i])
				ans.append(high[i + 1])
			ans.append(n - a)
		else:
			ans += [i for i in range(n - a, b + 1, -1)]
			ans.append(low[0])
			for i in range(a):
				ans.append(high[i])
				ans.append(low[i + 1])
			ans.append(b + 1)
		print(*ans)


from collections import deque
from sys import stdin
read = stdin.readline
from typing import DefaultDict
for _ in range(int(read())):
	(n, a, b) = map(int, read().split())
	if a + b > n - 2:
		print(-1)
		continue
	elif abs(a - b) > 1:
		print(-1)
		continue
	else:
		ans = []
		if a == b:
			num = 1
			ctr = 1
			while ctr < a + b + 2:
				if ctr % 2 == 1:
					ans.append(num)
				else:
					ans.append(a + b + 2 - num)
					num += 1
				ctr += 1
			for i in range(a + b + 2, n + 1):
				ans.append(i)
		elif a > b:
			num = 1
			ctr = 1
			while ctr < a + b + 2:
				if ctr % 2 == 1:
					ans.append(num + 1)
				else:
					ans.append(a + b + 2 - num + 1)
					num += 1
				ctr += 1
			for i in range(a + b + 2 + 1, n + 1):
				ans.append(i)
			ans.append(1)
		else:
			num = 1
			ctr = 1
			while ctr < a + b + 2:
				if ctr % 2 == 1:
					ans.append(num)
				else:
					ans.append(a + b + 2 - num)
					num += 1
				ctr += 1
			for i in range(a + b + 2, n):
				ans.append(i)
			ans = [n] + ans
	print(*ans)


T = int(input())
for t in range(T):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or n - a - b < 2:
		print(-1)
		continue
	arr = [0] * n
	if a > b:
		j = n
		for i in range(1, n, 2):
			if a == 0:
				break
			arr[i] = j
			j -= 1
			a -= 1
		k = 1
		for i in range(2, n, 2):
			if b == 0:
				break
			arr[i] = k
			k += 1
			b -= 1
		for i in range(n - 1, -1, -1):
			if arr[i] == 0:
				arr[i] = k
				k += 1
	elif a < b:
		k = 1
		for i in range(1, n, 2):
			if b == 0:
				break
			arr[i] = k
			k += 1
			b -= 1
		j = n
		for i in range(2, n, 2):
			if a == 0:
				break
			arr[i] = j
			j -= 1
			a -= 1
		for i in range(n):
			if arr[i] == 0:
				arr[i] = k
				k += 1
	else:
		j = n
		for i in range(1, n, 2):
			if a == 0:
				break
			arr[i] = j
			j -= 1
			a -= 1
		k = 1
		for i in range(2, n, 2):
			if b == 0:
				break
			arr[i] = k
			k += 1
			b -= 1
		for i in range(n):
			if arr[i] == 0:
				arr[i] = k
				k += 1
	print(*arr)


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def main(t):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		return
	if a >= b:
		ans = [i + 1 for i in range(n)]
		if b > 0:
			for i in range(1, n, 2):
				(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
				a -= 1
				b -= 1
				if b == 0:
					break
		if a > 0:
			(ans[-1], ans[-2]) = (ans[-2], ans[-1])
	else:
		ans = [n - i for i in range(n)]
		if a > 0:
			for i in range(1, n, 2):
				(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
				a -= 1
				b -= 1
				if a == 0:
					break
		(ans[-1], ans[-2]) = (ans[-2], ans[-1])
	print(*ans)
T = int(input())
t = 1
while t <= T:
	main(t)
	t += 1


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1:
		print(-1)
		continue
	mx = n
	mn = 1
	ans = []
	first_time = True
	increment = a < b
	if a > b:
		if n < 2 * a + 1:
			print(-1)
			continue
		while a > 0:
			ans.append(mn)
			ans.append(mx)
			mn += 1
			mx -= 1
			a -= 1
			if not first_time:
				b -= 1
			first_time = False
	else:
		if n < 2 * b + 1 or (a == b and n < 2 * b + 2):
			print(-1)
			continue
		while b > 0:
			ans.append(mx)
			ans.append(mn)
			mn += 1
			mx -= 1
			b -= 1
			if not first_time:
				a -= 1
			first_time = False
	if increment:
		ans.extend(range(mn, mx + 1))
	else:
		ans.extend(range(mx, mn - 1, -1))
	print(' '.join(map(str, ans)))


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if a > (n - 1) // 2 or b > (n - 1) // 2 or a + b > n - 2 or (abs(a - b) > 1) or (min(a, b) > (n - 2) // 2) or (max(a, b) > (n - 1) // 2):
		print(-1)
	elif a < b:
		li = []
		c = 1
		d = n
		for i in range(0, 2 * b):
			if i % 2 == 0:
				li.append(d)
				d -= 1
			else:
				li.append(c)
				c += 1
		for i in range(c, d + 1):
			li.append(i)
		print(*li)
	elif b < a:
		li = []
		c = 1
		d = n
		for i in range(0, 2 * a):
			if i % 2 == 1:
				li.append(d)
				d -= 1
			else:
				li.append(c)
				c += 1
		for i in range(d, c - 1, -1):
			li.append(i)
		print(*li)
	else:
		li = []
		c = 1
		d = n
		for i in range(0, 2 * a):
			if i % 2 == 0:
				li.append(d)
				d -= 1
			else:
				li.append(c)
				c += 1
		for i in range(d, c - 1, -1):
			li.append(i)
		print(*li)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	z = [i for i in range(1, n + 1)]
	l = []
	if a + b > n - 2:
		print(-1)
	elif abs(a - b) > 1:
		print(-1)
	elif a > b:
		for i in range(0, a):
			l.append(z[i])
			l.append(z[-(i + 1)])
		print(*l + list(reversed(z[a:-a])))
	elif a == b and (a > 0 and b > 0):
		for i in range(0, a):
			l.append(z[i])
			l.append(z[-(i + 1)])
		print(*l + z[a:-a])
	elif a == 0 and b == 0:
		for i in range(1, n + 1):
			l.append(i)
		print(*l)
	else:
		for i in range(0, b):
			l.append(z[-(i + 1)])
			l.append(z[i])
		print(*l + z[b:-b])


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split(' '))
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		perm = []
		if a == b:
			for delta in range(b):
				perm.append(n - delta)
				perm.append(delta + 1)
			perm.insert(0, b + 1)
			for kappa in range(b + 2, n - (b - 1)):
				perm.append(kappa)
		elif a > b:
			for theta in range(b):
				perm.append(n - theta)
				perm.append(theta + 1)
			perm.append(n - b)
			perm.insert(0, b + 1)
			for alpha in range(n - b - 1, b + 1, -1):
				perm.append(alpha)
		else:
			for beta in range(a):
				perm.append(beta + 1)
				perm.append(n - beta)
			perm.append(a + 1)
			perm.insert(0, n - a)
			for gamma in range(a + 2, n - a):
				perm.append(gamma)
		print(*perm)


t = int(input())
for i in range(t):
	[n, a, b] = list(map(int, input().split(' ')))
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	res = [0]
	abss = 1
	init_pos = a >= b
	pos = init_pos
	for i in range(a + b + 1):
		res.append(abss * (1 if pos else -1))
		if init_pos == pos:
			pos = not init_pos
		else:
			pos = not pos
			abss += 1
	for i in range(a + b + 1, n - 1):
		last = res[-1]
		if last >= 0:
			res.append(last + 1)
		else:
			res.append(last - 1)
	minim = min(res)
	res = [x + -minim + 1 for x in res]
	print(' '.join(map(str, res)))


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	z = list((i + 1 for i in range(n)))
	s = len(z)
	if a + b <= n - 2 and abs(a - b) <= 1:
		if a == b:
			x = z[s - b:]
			y = z[:s - b]
		elif a > b:
			x = z[s - a:]
			y = list(reversed(z[:s - a]))
		else:
			x = z[:b]
			y = z[b:]
		j = 0
		k = 0
		while j < len(y) and k < len(x):
			if j % 2 != 0:
				y.insert(j, x[k])
				k += 1
			j += 1
		print(*y)
	else:
		print(-1)


import os
import sys
from io import BytesIO, IOBase
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

def nextPowerOf2(n):
	p = 1
	if n and (not n & n - 1):
		return n
	while p < n:
		p <<= 1
	return p

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

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

def isprime(n):
	if n == 1:
		return 0
	i = 2
	while i * i <= n:
		if n % i == 0:
			return 0
		i += 1
	return 1

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

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

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

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)
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')

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


import math
import sys
input = sys.stdin.readline
S = lambda : input().rstrip()
I = lambda : int(S())
M = lambda : map(int, S().split())
L = lambda : list(M())
mod1 = 1000000007
mod2 = 998244353
for _ in range(I()):
	(n, a, b) = M()
	(a1, b1) = (a, b)
	if max(a, b) > (n - 1) // 2 or abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	i = 1
	j = n
	if a >= b:
		ans = [i, j]
		i += 1
		j -= 1
		c = 0
		while a > 0 or b > 0:
			if c % 2 == 0:
				ans.append(i)
				a -= 1
				i += 1
			else:
				ans.append(j)
				b -= 1
				j -= 1
			c += 1
	else:
		ans = [j, i]
		j -= 1
		i += 1
		c = 0
		while a > 0 or b > 0:
			if c % 2 == 0:
				ans.append(j)
				b -= 1
				j -= 1
			else:
				ans.append(i)
				a -= 1
				i += 1
			c += 1
	p = len(ans)
	for k in range(i, j + 1):
		ans.append(k)
	if a1 > b1:
		ans = ans[:p - 1] + sorted(ans[p - 1:], reverse=True)
	else:
		ans = ans[:p - 1] + sorted(ans[p - 1:])
	print(*ans)


i = int(input())

def f(n, a, b):
	if abs(a - b) > 1 or a + b > n - 2:
		return [-1]
	perm = []
	if a >= b:
		for i in range(1, n - a - b):
			perm.append(i)
		lower = n - a - b
		upper = n
		while lower < upper:
			perm.append(upper)
			perm.append(lower)
			upper -= 1
			lower += 1
		if lower == upper:
			perm.append(lower)
	else:
		for i in range(n - a - b, 0, -1):
			perm.append(i)
		lower = n - a - b + 1
		upper = n
		while lower < upper:
			perm.append(upper)
			perm.append(lower)
			upper -= 1
			lower += 1
		if lower == upper:
			perm.append(lower)
	return perm
for w in range(0, i):
	[n, a, b] = [int(x) for x in input().split()]
	print(' '.join([str(x) for x in f(n, a, b)]))


def solve(n, a, b):
	ans = [i for i in range(1, n + 1)]
	if a + b == 0:
		return ans
	if a + b > n - 2 or abs(a - b) > 1:
		return [-1]
	if a > b:
		j = n - 1
		for _ in range(a):
			(ans[j], ans[j - 1]) = (ans[j - 1], ans[j])
			j -= 2
	elif b > a:
		j = 0
		for _ in range(b):
			(ans[j], ans[j + 1]) = (ans[j + 1], ans[j])
			j += 2
	else:
		for i in range(1, 2 * a + 1, 2):
			(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
	return ans
ans = []
for _ in range(int(input())):
	ans.append(solve(*list(map(int, input().split()))))
for an in ans:
	print(*an)


from sys import stdin
input = stdin.readline
from math import ceil

def answer(a, b):
	if a == 0 and b == 0:
		return [i for i in range(1, n + 1)]
	if n == 2 and (a or b):
		return [-1]
	if abs(a - b) > 1:
		return [-1]
	(ans, front, back) = ([], 1, n)
	if a > b:
		ans.append(front)
		ans.append(back)
		(front, back) = (front + 1, back - 1)
		turn = 1
		while front <= back:
			if b == 0:
				break
			if turn == 1:
				ans.append(front)
				a -= 1
				front += 1
			else:
				ans.append(back)
				b -= 1
				back -= 1
			turn ^= 1
		if front <= back:
			a -= 1
		while front <= back:
			ans.append(back)
			back -= 1
	elif a < b:
		ans.append(back)
		ans.append(front)
		(front, back) = (front + 1, back - 1)
		turn = 1
		while front <= back:
			if a == 0:
				break
			if turn == 1:
				ans.append(back)
				b -= 1
				back -= 1
			else:
				ans.append(front)
				a -= 1
				front += 1
			turn ^= 1
		if front <= back:
			b -= 1
		while front <= back:
			ans.append(front)
			front += 1
	else:
		ans.append(front)
		ans.append(back)
		(front, back) = (front + 1, back - 1)
		turn = 1
		while front <= back:
			if a == 0 and b == 1:
				break
			if turn == 1:
				ans.append(front)
				a -= 1
				front += 1
			else:
				ans.append(back)
				b -= 1
				back -= 1
			turn ^= 1
		if front <= back:
			b -= 1
		while front <= back:
			ans.append(front)
			front += 1
	if a or b:
		return [-1]
	return ans
for T in range(int(input())):
	(n, a, b) = map(int, input().split())
	print(*answer(a, b))


n = int(input())
for i in range(n):
	(kolvo, max, min) = map(int, input().split())
	answer = str()
	if abs(max - min) > 1 or max + min > kolvo - 2:
		print('-1')
	elif max == min:
		i = 2
		answer += '1' + ' '
		while max > 0:
			max -= 1
			answer += str(i + 1) + ' ' + str(i) + ' '
			i += 2
		while i <= kolvo:
			answer += str(i) + ' '
			i += 1
		print(answer)
	elif max > min:
		i = 2
		answer += '1' + ' '
		while min > 0:
			min -= 1
			answer += str(i + 1) + ' ' + str(i) + ' '
			i += 2
		while kolvo >= i:
			answer += str(kolvo) + ' '
			kolvo -= 1
		print(answer)
	else:
		i = kolvo - 1
		answer += str(kolvo) + ' '
		while max > 0:
			max -= 1
			answer += str(i - 1) + ' ' + str(i) + ' '
			i -= 2
		kolvo = 1
		while kolvo <= i:
			answer += str(kolvo) + ' '
			kolvo += 1
		print(answer)


import sys
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')
depth = 200001
mod = 1000000007
lim = mod * mod
sys.setrecursionlimit(depth)
linp = lambda : list(minp())
minp = lambda : map(int, input().split())
from math import inf, ceil, sqrt, log2, gcd
from collections import defaultdict, deque
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]

def expo(a, b):
	if not b:
		return 1
	v = expo(a, b // 2)
	v = v * v % mod
	if b % 2:
		v = v * a % mod
	return v

def modinv(a, b):
	d = expo(b, mod - 2)
	v = a * d % mod
	return v

def checkPrime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	for i in range(3, int(sqrt(n)) + 1, 2):
		if n % i == 0:
			return False
	return True

def highestPowerof2(x):
	x |= x >> 1
	x |= x >> 2
	x |= x >> 4
	x |= x >> 8
	x |= x >> 16
	return x ^ x >> 1
for _ in range(int(input())):
	(n, a, b) = minp()
	if a + b + 2 > n or abs(a - b) > 1:
		print(-1)
		continue
	if a >= b:
		v = [i + 1 for i in range(n)]
	else:
		v = [n - i for i in range(n)]
	for i in range(1, n - 2, 2):
		if not a or not b:
			break
		(v[i], v[i + 1]) = (v[i + 1], v[i])
		(a, b) = (a - 1, b - 1)
	if a or b:
		(v[-1], v[-2]) = (v[-2], v[-1])
	print(*v)


from sys import stdin, stdout, setrecursionlimit
from math import gcd, sqrt, factorial, pi, inf
from collections import deque, defaultdict
from bisect import bisect, bisect_left
from time import time
from itertools import permutations as per
from heapq import heapify, heappush, heappop, heappushpop
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\r\n')
L = lambda : list(R())
P = lambda x: stdout.write(str(x) + '\n')
lcm = lambda x, y: x * y // gcd(x, y)
nCr = lambda x, y: f[x] * inv(f[y] * f[x - y] % N) % N
inv = lambda x: pow(x, N - 2, N)
sumx = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7
for _ in range(I()):
	(n, a, b) = R()
	ans = [i + 1 for i in range(n)]
	if abs(a - b) > 1 or a + b + 2 > n:
		print(-1)
	elif a > b:
		i = 0
		while i < a:
			(ans[-1 - i * 2], ans[-2 - i * 2]) = (ans[-2 - i * 2], ans[-1 - i * 2])
			i += 1
		print(*ans)
	elif a < b:
		i = 0
		while i < b:
			(ans[i * 2], ans[1 + 2 * i]) = (ans[1 + 2 * i], ans[2 * i])
			i += 1
		print(*ans)
	else:
		i = 0
		while i < a:
			(ans[i * 2 + 2], ans[1 + 2 * i]) = (ans[1 + 2 * i], ans[2 * i + 2])
			i += 1
		print(*ans)


for _ in range(int(input())):
	(n, a, b) = list(map(int, input().split()))
	arr = [i for i in range(1, n + 1)]
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	elif a > b:
		i = n - 1
		while a:
			temp = arr[i]
			arr[i] = arr[i - 1]
			arr[i - 1] = temp
			i -= 2
			a -= 1
		print(*arr, sep=' ')
	elif b > a:
		i = 0
		while b:
			temp = arr[i]
			arr[i] = arr[i + 1]
			arr[i + 1] = temp
			i += 2
			b -= 1
		print(*arr, sep=' ')
	else:
		i = 1
		while b:
			temp = arr[i]
			arr[i] = arr[i + 1]
			arr[i + 1] = temp
			i += 2
			b -= 1
		print(*arr, sep=' ')


for _ in range(int(input())):
	(n, m, k) = map(int, input().split())
	a = [0 for i in range(n)]
	if m > k:
		z = n
		i = 1
		for l in range(m):
			if i >= n:
				break
			a[i] = z
			z -= 1
			i += 2
		for i in range(len(a)):
			if a[i] == 0:
				a[i] = z
				z -= 1
	elif m < k:
		z = 1
		i = 1
		for l in range(k):
			if i >= n:
				break
			a[i] = z
			z += 1
			i += 2
		for i in range(len(a)):
			if a[i] == 0:
				a[i] = z
				z += 1
	else:
		z = 1
		i = 0
		for l in range(k + 1):
			if i >= n:
				break
			a[i] = z
			z += 1
			i += 2
		for i in range(len(a)):
			if a[i] == 0:
				a[i] = z
				z += 1
	for i in range(1, len(a) - 1):
		if a[i] > a[i - 1] and a[i] > a[i + 1]:
			m -= 1
		if a[i] < a[i - 1] and a[i] < a[i + 1]:
			k -= 1
	if m == k and m == 0:
		for i in a:
			print(i, end=' ')
		print()
	else:
		print(-1)


import sys
input = sys.stdin.readline

def get_int():
	return int(input().rstrip())

def get_arr():
	return [int(w) for w in input().split()]
t = get_int()
for _ in range(t):
	(n, a, b) = get_arr()
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		ans = []
		if a == b:
			for (x, y) in zip(range(1, a + 1), range(n, n - b, -1)):
				ans.append(x)
				ans.append(y)
			ans += list(range(a + 1, n - b + 1))
		if a > b:
			for (x, y) in zip(range(1, a + 1), range(n, n - a, -1)):
				ans.append(x)
				ans.append(y)
			ans += list(range(n - a, a, -1))
		if a < b:
			for (x, y) in zip(range(n, n - b, -1), range(1, b + 1)):
				ans.append(x)
				ans.append(y)
			ans += list(range(b + 1, n - b + 1))
		print(*ans)


import sys
t = int(sys.stdin.readline())
ans = []
for _ in range(t):
	(n, a, b) = map(int, sys.stdin.readline().split())
	if abs(a - b) > 1 or n < a + b + 2:
		ans.append('-1')
		continue
	arr = [0] * n
	if a > b:
		for i in range(a):
			arr[i * 2] = i + 1
		for i in range(b):
			arr[i * 2 + 1] = i + a + 1
		arr[a + b:] = range(n, a + b, -1)
	elif a == b:
		for i in range(a + 1):
			arr[i * 2] = i + 1
		for i in range(b):
			arr[i * 2 + 1] = i + a + 2
		arr[a + b + 1:] = range(a + b + 2, n + 1)
	else:
		for i in range(b):
			arr[i * 2] = i + b + 1
		for i in range(b):
			arr[i * 2 + 1] = i + 1
		arr[a + b + 1:] = range(a + b + 2, n + 1)
	ans.append(' '.join(map(str, arr)))
sys.stdout.write('\n'.join(ans))


from sys import stdin, stdout
import math
for _ in range(int(stdin.readline())):
	(n, a, b) = map(int, stdin.readline().split())
	ar = [i for i in range(1, n + 1)]
	if a > (n - 1) // 2 or b > (n - 1) // 2 or abs(a - b) > 1 or (a + b > n - 2):
		print('-1')
	else:
		if a > b:
			a -= 1
			temp = ar[-1]
			ar[-1] = ar[-2]
			ar[-2] = temp
			for i in range(1, 2 * a + 1, 2):
				temp = ar[i]
				ar[i] = ar[i + 1]
				ar[i + 1] = temp
		elif b > a:
			b -= 1
			temp = ar[1]
			ar[1] = ar[0]
			ar[0] = temp
			for i in range(n - 2, n - 1 - 2 * a, -2):
				temp = ar[i]
				ar[i] = ar[i - 1]
				ar[i - 1] = temp
		else:
			for i in range(1, 2 * a + 1, 2):
				temp = ar[i]
				ar[i] = ar[i + 1]
				ar[i + 1] = temp
		for i in ar:
			print(i, end=' ')
		print()


import os
import sys
from io import BytesIO, IOBase
from collections import Counter, defaultdict
import math
import heapq
import bisect
import collections
import copy

def ceil(a, b):
	return (a + b - 1) // b
sys.setrecursionlimit(10 ** 5)
BUFSIZE = 8192
inf = float('inf')

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, **kwargs):
		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))
get = lambda : sys.stdin.readline().rstrip('\r\n')
MOD = 1000000007

def v():
	return list()
for _ in range(int(get())):
	(n, a, b) = map(int, get().split())
	ans = [i + 1 for i in range(n)]
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	else:
		if a > b:
			i = n - 1
			while a:
				a -= 1
				(ans[i], ans[i - 1]) = (ans[i - 1], ans[i])
				i -= 2
		elif a < b:
			i = 0
			while b:
				b -= 1
				(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
				i += 2
		else:
			i = 1
			while b:
				b -= 1
				(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
				i += 2
		print(*ans)


from collections import deque as dq
import sys
input = sys.stdin.readline
inp_lis = lambda : list(map(int, input().split()))
inp_multi = lambda : map(int, input().split())
inp_int = lambda : int(input().strip())
for _ in range(int(input().strip())):
	(n, a, b) = inp_multi()
	if n - 2 < a + b or abs(a - b) > 1:
		print(-1)
		continue
	if a == 0 and b == 0:
		for w in range(1, n + 1):
			print(w, end=' ')
		print()
		continue
	if a > b:
		d = dq([])
		i = n
		for w in range(a):
			d.appendleft(i - 1)
			d.appendleft(i)
			i -= 2
		for w in range(i, 0, -1):
			d.appendleft(w)
	elif b > a:
		d = dq([])
		i = 1
		for w in range(b):
			d.append(i + 1)
			d.append(i)
			i += 2
		for w in range(i, n + 1):
			d.append(w)
	else:
		x = a + b
		for w in range(1, x + 1, 2):
			print(w + 1, w, sep=' ', end=' ')
		for w in range(x + 1, n - 1):
			print(w, end=' ')
		print(n, n - 1, sep=' ', end=' ')
		print()
		continue
	d = list(d)
	print(*d)


from math import ceil
t = int(input())
for tc in range(t):
	(n, a, b) = map(int, input().split())
	(a, b) = (b, a)
	if a + b > n - 2 or abs(a - b) > 1:
		print('-1')
	elif a == b:
		ans = [1]
		for i in range(1, a + 1):
			ans.append(n - i + 1)
			ans.append(i + 1)
		for i in range(a + 2, n - a + 1):
			ans.append(i)
		print(*ans)
	elif a + 1 == b:
		ans = [1]
		for i in range(1, a + 1):
			ans.append(n - i + 1)
			ans.append(i + 1)
		tail = []
		for i in range(a + 2, n - a + 1):
			tail.append(i)
		print(*ans, *tail[::-1])
	elif a == b + 1:
		(a, b) = (b, a)
		ans = [1]
		for i in range(1, a + 1):
			ans.append(n - i + 1)
			ans.append(i + 1)
		tail = []
		for i in range(a + 2, n - a + 1):
			tail.append(i)
		aans = ans + tail[::-1]
		print(*[n - v + 1 for v in aans])


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if a + b + 2 > n:
		print(-1)
	elif abs(a - b) > 1:
		print(-1)
	elif a == b - 1:
		print(b + 1, end=' ')
		for i in range(a):
			print(1 + i, end=' ')
			print(n - a + 1 + i, end=' ')
		print(b, end=' ')
		for i in range(n - a - b - 1):
			print(b + 2 + i, end=' ')
		print()
	elif a == b:
		print(n - a, end=' ')
		for i in range(a):
			print(1 + i, end=' ')
			print(n - a + 1 + i, end=' ')
		for i in range(n - a - b - 1):
			print(n - a - i - 1, end=' ')
		print()
	elif a == b + 1:
		print(b + 1, end=' ')
		for i in range(b):
			print(n - a + 1 + i, end=' ')
			print(1 + i, end=' ')
		print(n, end=' ')
		for i in range(n - a - b - 1):
			print(n - a - i, end=' ')
		print()


num_tests = int(input())
for _ in range(num_tests):
	(n, maxs, mins) = [int(x) for x in input().split()]
	diff = maxs - mins
	summ = maxs + mins
	bot_val = 1
	top_val = n
	if diff > 1 or diff < -1 or summ > n - 2:
		print(-1)
	elif diff == 1:
		for i in range(summ + 1):
			if i % 2 == 0:
				print(bot_val, end=' ')
				bot_val += 1
			else:
				print(top_val, end=' ')
				top_val -= 1
		for _ in range(n - summ - 1):
			print(top_val, end=' ')
			top_val -= 1
		print()
	elif diff == 0:
		for i in range(summ + 1):
			if i % 2 == 0:
				print(bot_val, end=' ')
				bot_val += 1
			else:
				print(top_val, end=' ')
				top_val -= 1
		for _ in range(n - summ - 1):
			print(bot_val, end=' ')
			bot_val += 1
		print()
	elif diff == -1:
		for i in range(summ + 1):
			if i % 2 == 1:
				print(bot_val, end=' ')
				bot_val += 1
			else:
				print(top_val, end=' ')
				top_val -= 1
		for _ in range(n - summ - 1):
			print(bot_val, end=' ')
			bot_val += 1
		print()


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 = 1e-07
x = 0
pref = []
lvl = []
gp = []
ans = []
f = 0
w = []

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)


for i in range(int(input())):
	(n, a, b) = [int(j) for j in input().split()]
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	elif a > b:
		for x in range(a):
			print(x + 1, end=' ')
			print(n - x, end=' ')
		for y in range(n - 2 * a):
			print(n - x - y - 1, end=' ')
		print()
	elif b > a:
		for x in range(b):
			print(n - x, end=' ')
			print(x + 1, end=' ')
		for y in range(n - 2 * b):
			print(x + 2 + y, end=' ')
		print()
	else:
		print(1, end=' ')
		for x in range(a):
			print(n - x, end=' ')
			print(x + 2, end=' ')
		for y in range(n - 1 - 2 * a):
			print(a + y + 2, end=' ')
		print()


from __future__ import division, print_function
import math
import sys
import os
from io import BytesIO, IOBase
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def inp():
	return int(input())

def inps():
	return input().strip()

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
for _ in range(inp()):
	(n, a, b) = invr()
	if abs(a - b) > 1:
		print(-1)
	elif a > (n - 1) // 2 or b > (n - 1) // 2:
		print(-1)
	elif n % 2 and a == b == n // 2:
		print(-1)
	else:
		l = [0 for i in range(n)]
		if a > b:
			temp = n
			for i in range(1, 2 * a, 2):
				l[i] = temp
				temp -= 1
			for i in range(0, 2 * a + 1, 2):
				l[i] = temp
				temp -= 1
			for i in range(n):
				if l[i] == 0:
					l[i] = temp
					temp -= 1
			print(*l)
		elif b > a:
			temp = 1
			for i in range(1, 2 * b, 2):
				l[i] = temp
				temp += 1
			for i in range(0, 2 * b + 1, 2):
				l[i] = temp
				temp += 1
			for i in range(n):
				if l[i] == 0:
					l[i] = temp
					temp += 1
			print(*l)
		else:
			temp = 1
			for i in range(0, 2 * b + 1, 2):
				l[i] = temp
				temp += 1
			for i in range(1, 2 * b + 3, 2):
				l[i] = temp
				temp += 1
			for i in range(n):
				if l[i] == 0:
					l[i] = temp
					temp += 1
			print(*l)


num_tests = int(input())
for _ in range(num_tests):
	(n, a, b) = (int(num) for num in input().split(' '))
	if abs(a - b) <= 1 and a + b <= n - 2:
		if a > b:
			l = []
			for i in range(a):
				l.append(1 + i)
				l.append(n - i)
			l.extend(range(n - a, a, -1))
			print(*l)
		elif b > a:
			l = []
			for i in range(b):
				l.append(n - i)
				l.append(1 + i)
			l.extend(range(b + 1, n - b + 1))
			print(*l)
		elif a == b:
			l = [1]
			for i in range(a):
				l.append(n - i)
				l.append(2 + i)
			l.extend(range(a + 2, n - a + 1))
			print(*l)
	else:
		print(-1)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	arr = [x for x in range(1, n + 1)]
	if a + b > n - 2 or abs(a - b) > 1:
		print(-1)
	elif a == b:
		ar = []
		m = a + b + 2
		for i in range(n, m, -1):
			ar.append(i)
		for i in range(2, m + 1, 2):
			ar.append(i)
			ar.append(i - 1)
		print(*ar)
	elif a == b - 1:
		for i in range(0, 2 * b, 2):
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
		print(*arr)
	elif a == b + 1:
		for i in range(n - 1, n - 2 * a, -2):
			(arr[i], arr[i - 1]) = (arr[i - 1], arr[i])
		print(*arr)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	if max(a, b) > n - (n - 1) // 2 or abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	x = 1
	y = n
	ans = []
	if a > b:
		for i in range(a + b + 1):
			if i % 2:
				ans.append(y)
				y -= 1
			else:
				ans.append(x)
				x += 1
		for k in range(y, x - 1, -1):
			ans.append(k)
	elif a == b:
		for i in range(a + b + 1):
			if i % 2:
				ans.append(y)
				y -= 1
			else:
				ans.append(x)
				x += 1
		for k in range(x, y + 1):
			ans.append(k)
	else:
		for i in range(a + b + 1):
			if i % 2:
				ans.append(x)
				x += 1
			else:
				ans.append(y)
				y -= 1
		for k in range(x, y + 1):
			ans.append(k)
	print(*ans)


import sys, os, io
import math
from collections import defaultdict

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def solve():
	(n, a, b) = li()
	cnt = n - 2
	if n == 2:
		if a == b == 0:
			print(1, 2)
		else:
			print(-1)
		return
	if a + b > cnt:
		print(-1)
		return
	if abs(a - b) > 1:
		print(-1)
		return
	if b >= a:
		ans = [i for i in range(1, n + 1)]
		ans.reverse()
		ind = 1
		for i in range(b):
			(ans[ind], ans[ind + 1]) = (ans[ind + 1], ans[ind])
			ind += 2
		if b > a:
			x = ans[ind - 1]
			y = ans[ind:]
			ans[ind - 1:-1] = y
			ans[-1] = x
	else:
		ans = [i for i in range(1, n + 1)]
		ans.reverse()
		ind = 1
		for i in range(a):
			(ans[ind], ans[ind + 1]) = (ans[ind + 1], ans[ind])
			ind += 2
		x = ans[ind - 1]
		y = ans[ind:]
		ans[ind - 1:-1] = y
		ans[-1] = x
		for i in range(n):
			ans[i] = n - ans[i] + 1
	print(*ans)
t = 1
t = ii()
for _ in range(t):
	solve()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def st():
	return input().rstrip('\n')

def lis():
	return list(map(int, input().split()))

def ma():
	return map(int, input().split())
t = inp()
while t:
	t -= 1
	(n, a, b) = ma()
	have = (n - 2) // 2
	have += (n - 2) % 2
	if abs(a - b) > 1:
		print(-1)
	elif a > have or b > have or a + b > n - 2:
		print(-1)
	else:
		if a > b:
			vis = [0] * (n + 1)
			res = []
			lf = 1
			rf = n
			for i in range(n):
				if a == 0:
					break
				if i % 2 == 0:
					res.append(lf)
					vis[lf] = 1
					lf += 1
				else:
					res.append(rf)
					vis[rf] = 1
					rf -= 1
					a -= 1
			for i in range(n, 0, -1):
				if vis[i] == 0:
					res.append(i)
		elif b > a:
			lf = 1
			rf = n
			vis = [0] * (n + 1)
			res = []
			for i in range(n):
				if b == 0:
					break
				if i % 2:
					res.append(lf)
					vis[lf] = 1
					lf += 1
					b -= 1
				else:
					res.append(rf)
					vis[rf] = 1
					rf -= 1
			for i in range(1, n + 1):
				if vis[i] == 0:
					res.append(i)
		else:
			vis = [0] * (n + 1)
			res = []
			lf = 1
			rf = n
			for i in range(n):
				if a == 0 and b == -1:
					break
				if i % 2 == 0:
					res.append(lf)
					vis[lf] = 1
					lf += 1
					b -= 1
				else:
					res.append(rf)
					vis[rf] = 1
					rf -= 1
					a -= 1
			for i in range(1, n + 1):
				if vis[i] == 0:
					res.append(i)
		print(*res)


try:
	t = int(input())
	while t:
		(n, a, b) = map(int, input().split())
		ans = [i for i in range(1, n + 1)]
		if n % 2 == 0:
			if a > n // 2 - 1 or b > n // 2 - 1 or abs(a - b) > 1:
				print(-1)
				continue
			if a == b:
				i = 0
				while a:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					a -= 1
					i += 2
				if b:
					(ans[-1], ans[-2]) = (ans[-2], ans[-1])
			elif b > a:
				i = 0
				while b:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					b -= 1
					i += 2
			else:
				i = 1
				while a - 1:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					a -= 1
					i += 2
				(ans[-1], ans[-2]) = (ans[-2], ans[-1])
			print(*ans)
		else:
			if a > n // 2 or b > n // 2 or abs(a - b) > 1:
				print(-1)
				continue
			if a == n // 2 and b != a - 1 or (b == n // 2 and a != b - 1):
				print(-1)
				continue
			if a == b:
				i = 0
				while a:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					a -= 1
					i += 2
				if b:
					(ans[-1], ans[-2]) = (ans[-2], ans[-1])
			elif b > a:
				i = 0
				while b:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					b -= 1
					i += 2
			else:
				i = 1
				while a - 1:
					(ans[i], ans[i + 1]) = (ans[i + 1], ans[i])
					a -= 1
					i += 2
				(ans[-1], ans[-2]) = (ans[-2], ans[-1])
			print(*ans)
		t -= 1
except:
	pass


import sys
from math import factorial, gcd
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush, heapify, nlargest, nsmallest
from itertools import groupby
from copy import deepcopy
MOD = 10 ** 9 + 7
INF = float('inf')
input = sys.stdin.readline
rl = lambda : list(map(int, input().split()))
rs = lambda : sys.stdin.readline().strip()

def ceil(a, b):
	return (a + b - 1) // b
for _ in range(int(input())):
	(n, a, b) = rl()
	if ceil(n, 2) <= a or ceil(n, 2) <= b or n - 2 < a + b or (abs(a - b) >= 2):
		print(-1)
		continue
	res = [i for i in range(1, n + 1)]
	if a > b:
		i = n - 1
		while a:
			(res[i], res[i - 1]) = (res[i - 1], res[i])
			a -= 1
			i -= 2
	elif a < b:
		res = res[::-1]
		i = n - 1
		while b:
			(res[i], res[i - 1]) = (res[i - 1], res[i])
			b -= 1
			i -= 2
	else:
		i = 1
		while a:
			(res[i], res[i + 1]) = (res[i + 1], res[i])
			i += 2
			a -= 1
	print(*res)


t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
	elif a > b:
		lst = [0] * (a + b + 1)
		lsts = []
		lstr = []
		for y in range(1, n + 1):
			lsts.append(y)
		for l in range(n, 0, -1):
			lstr.append(l)
		c = 0
		d = 1
		while c != a:
			lst[d] = lstr[c]
			d += 2
			c += 1
		d = 2
		c = 0
		while c != b:
			lst[d] = lsts[c]
			d += 2
			c += 1
		lsto = []
		for x in range(b + 1, n - a + 1):
			lsto.append(x)
		lsto.sort(reverse=True)
		lst[0] = lsto[0]
		lst = lst + lsto[1:]
		print(*lst)
	elif b > a:
		lst = [0] * (a + b + 1)
		lsts = []
		lstr = []
		for y in range(1, n + 1):
			lsts.append(y)
		for l in range(n, 0, -1):
			lstr.append(l)
		c = 0
		d = 1
		while c != b:
			lst[d] = lsts[c]
			d += 2
			c += 1
		d = 2
		c = 0
		while c != a:
			lst[d] = lstr[c]
			d += 2
			c += 1
		lsto = []
		for x in range(b + 1, n - a + 1):
			lsto.append(x)
		lsto.sort()
		lst[0] = lsto[0]
		lst = lst + lsto[1:]
		print(*lst)
	else:
		lst = [0] * (a + b + 1)
		lsts = []
		lstr = []
		for y in range(1, n + 1):
			lsts.append(y)
		for l in range(n, 0, -1):
			lstr.append(l)
		c = 0
		d = 1
		while c != b:
			lst[d] = lsts[c]
			d += 2
			c += 1
		d = 2
		c = 0
		while c != a:
			lst[d] = lstr[c]
			d += 2
			c += 1
		lsto = []
		for x in range(b + 1, n - a + 1):
			lsto.append(x)
		lsto.sort(reverse=True)
		lst[0] = lsto[0]
		lst = lst + lsto[1:]
		print(*lst)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	numbers = list(range(1, n + 1))
	if abs(a - b) > 1 or a + b > n - 2:
		print(-1)
		continue
	if a == b:
		i = 1
	elif a > b:
		i = 0
		numbers = numbers[::-1]
	elif b > a:
		i = 0
	integer = max(a, b)
	while integer > 0:
		numbers.insert(i, numbers.pop(-1))
		i += 2
		integer -= 1
	print(*numbers)


for _ in range(int(input())):

	def main():
		(n, a, b) = map(int, input().split())
		if abs(a - b) > 1:
			return print(-1)
		nums = []
		if a > b:
			if n < a * 2 + 1:
				return print(-1)
			nums.append(1)
			for i in range(n, a * 2 + 1, -1):
				nums.append(i)
			for i in range(a):
				nums.append(a * 2 + 1 - i)
				nums.append(i + 2)
		elif a == b:
			if n < a * 2 + 2:
				return print(-1)
			for i in range(n, a * 2 + 2, -1):
				nums.append(i)
			for i in range(a + 1):
				nums.append(a * 2 + 2 - i)
				nums.append(i + 1)
		else:
			if n < b * 2 + 1:
				return print(-1)
			for i in range(n, b * 2, -1):
				nums.append(i)
			for i in range(b):
				nums.append(i + 1)
				nums.append(b * 2 - i)
		print(' '.join(map(str, nums)))
	main()