import math

MAX_N = 10**6 + 10
is_prime = [True] * MAX_N
primes = []
spf = [0] * MAX_N  # Smallest prime factor array

# Эратосфеново решето для подготовки списка простых чисел
def sieve():
    is_prime[0], is_prime[1] = False, False
    p = 2
    while p*p < MAX_N:
        if is_prime[p]:
            primes.append(p)
            spf[p] = p
            for i in range(p*p, MAX_N, p):
                is_prime[i] = False
                spf[i] = p
        p += 1

sieve()  # Готовим список простых чисел

# Функция проверки, является ли число нечётно-степенным
def is_odd_powered(n):
    while n > 1:
        p = spf[n]
        exp = 0
        while n % p == 0:
            n //= p
            exp += 1
        if exp % 2 == 0:
            return False
    return True

# Генерация массива с флагами для каждого числа: 1 — нечётно-степенное, 0 — иначе
def preprocess(l, r):
    odd_powers = [0] * (r + 1)
    for i in range(l, r + 1):
        odd_powers[i] = 1 if is_odd_powered(i) else 0
    return odd_powers

# Основной алгоритм поиска m подряд идущих нечётно-степенных чисел
def solve(m, l, r):
    odd_powers = preprocess(l, r)
    
    # Префиксные суммы для быстрого подсчета количества нечётно-степенных чисел
    prefix_sum = [0] * (r + 2)
    for i in range(l, r + 1):
        prefix_sum[i + 1] = prefix_sum[i] + odd_powers[i]
    
    # Поиск окна из m подряд идущих нечётно-степенных чисел
    for start in range(l, r - m + 2):
        window_sum = prefix_sum[start + m] - prefix_sum[start]
        if window_sum == m:
            return list(range(start, start + m))
    
    return [-1]

# Чтение входных данных
m = int(input())  # Кол-во чисел в требуемой последовательности
l, r = map(int, input().split())  # Диапазон поиска

# Поиск и вывод результата
result = solve(m, l, r)
if result[0] == -1:
    print(-1)
else:
    print(" ".join(map(str, result)))