output_description: If there are no sequences that satisfy the conditions, print `-1`.
  
  Otherwise, print N integers. The i-th integer should be the i-th element of
  the sequence that you constructed.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N A B
attempt: import sys
  
  # from collections import defaultdict, deque
  # import math
  # import copy
  # from bisect import bisect_left, bisect_right
  # import heapq
  
  # sys.setrecursionlimit(1000000)
  
  # input aliases
  input = sys.stdin.readline
  
  getS = lambda: input().strip()
  getN = lambda: int(input())
  getList = lambda: list(map(int, input().split()))
  getZList = lambda: [int(x) - 1 for x in input().split()]
  
  INF = 10**20
  MOD = 1000000007
  
  
  class Segtree_op:
      def __init__(self, n):
          self.size = 1
          while n >= 1:
              self.size = self.size << 1
              n = n // 2
  
          self.arr = [self.unit() for i in range(self.size * 2)]
  
      def op(self, lch, rch):
          # update min with holding index
          return max(lch, rch)
  
      def unit(self):
          return -INF
  
      def update(self, k, val):
          k += self.size - 1
          self.arr[k] = val
          while k:
              k = (k - 1) // 2
              self.arr[k] = self.op(self.arr[k * 2 + 1], self.arr[k * 2 + 2])
  
      def query(self, l, r):
          L = l + self.size
          R = r + self.size
          s = self.unit()
          while L < R:
              if R & 1:
                  R -= 1
                  s = self.op(s, self.arr[R - 1])
  
              if L & 1:
                  s = self.op(s, self.arr[L - 1])
                  L += 1
              L >>= 1
              R >>= 1
          return s
  
      def show(self):
          idx = 1
          while idx <= self.size:
              print(self.arr[idx - 1 : idx * 2 - 1])
              idx *= 2
  
  
  def solve():
      n, a, b = getList()
      a, b = b, a
      if n < a + b - 1:
          print(-1)
          return
  
      if n > 2 * a + 2 * b - 3:
          print(-1)
          return
      if n == a + b - 1:
          ans = list(reversed([i for i in range(1, a + 1)])) + [
              i for i in range(a + 1, n + 1)
          ]
          print(*ans)
          return
      daini = min(n - a - b + 1, b - 1)
      ni = list(reversed([i for i in range(a + b, a + b + daini - 1)]))
      if n > a + b - 1 + daini:
          daisan = n - a - b + 1 - daini
          san = [i for i in range(n - daisan, n + 1)]
      else:
          san = []
      ans = (
          list(reversed([i for i in range(1, a + 1)]))
          + ni
          + san
          + [i for i in range(a + 1, a + b)]
      )
      print(*ans)
  
  
  def main():
      n = getN()
      for _ in range(n):
          solve()
  
  
  if __name__ == "__main__":
      # main()
      solve()
  
problem_description: Statement
  
  Determine if there exists a sequence obtained by permuting 1,2,...,N that
  satisfies the following conditions:
  
    * The length of its longest increasing subsequence is A.
    * The length of its longest decreasing subsequence is B.
  
  If it exists, construct one such sequence.
samples: [{"input": "5 3 2", "output": "2 4 1 5 3\n    \n\nOne longest increasing subsequence of this sequence is {2,4,5}, and one\nlongest decreasing subsequence of it is {4,3}.\n\n* * *"}, {"input": "7 7 1", "output": "1 2 3 4 5 6 7\n    \n\n* * *"}, {"input": "300000 300000 300000", "output": "-1"}]