def find_snack_combination():
    import sys
    N, D, K = map(int, sys.stdin.readline().split())
    
    def dfs(path, start, remaining, current_sum):
        if remaining == 0:
            if current_sum == D:
                return path
            else:
                return None
        
        for i in range(start, N + 1):
            new_sum = current_sum + i
            if new_sum > D:
                break  # Prune if sum exceeds D
            
            next_remaining = remaining - 1
            if next_remaining == 0:
                if new_sum == D:
                    return path + [i]
                else:
                    continue  # Skip if last element doesn't reach D
            
            required = D - new_sum
            m = next_remaining
            
            # Calculate minimum possible sum with next m elements starting from i+1
            a = i + 1
            if a + m - 1 > N:
                min_sum = (m * (a + (a + m - 1))) // 2
                if a > N:
                    min_sum = 0  # Invalid if there are not enough elements
            else:
                min_sum = (m * (2 * a + m - 1)) // 2
            
            # Calculate maximum possible sum with the largest m elements
            max_elem = N
            if max_elem < m:
                max_sum = 0  # Not enough elements
            else:
                max_sum = (m * (max_elem + (max_elem - m + 1))) // 2
            
            if min_sum > required or max_sum < required:
                continue  # Prune if sum cannot be achieved
            
            # Continue DFS
            result = dfs(path + [i], i + 1, next_remaining, new_sum)
            if result is not None:
                return result
        
        return None
    
    combination = dfs([], 1, K, 0)
    if combination:
        print(' '.join(map(str, combination)))
    else:
        print(-1)

find_snack_combination()