Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one. 

Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime. 

You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r. 

More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.


-----Input-----

The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 10^18; r - l ≤ 50).


-----Output-----

Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order. 

If the counterexample does not exist, print the single number -1.


-----Examples-----
Input
2 4

Output
2 3 4

Input
10 11

Output
-1

Input
900000000000000009 900000000000000029

Output
900000000000000009 900000000000000010 900000000000000021



-----Note-----

In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are. 

In the second sample you cannot form a group of three distinct integers, so the answer is -1. 

In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.

Difficulty: EASY
Tags: Mathematics

Number theory

Implementation

Complete search
Skill types: Complete search
Expected Time Complexity: O(1)

Starter code:

Solutions:
(l, r) = map(int, input().split())
(a, b, c) = (0, 0, 0)
for i in range(l, r - 1):
	for j in range(2, r - i + 1):
		if i % j == 0:
			a = i
			b = i + j // 2
			c = i + j
			if c % 2 == 0 and b % 2 == 0:
				b += 1
			print(a, b, c)
			exit()
print(-1)


(a, b) = map(int, input().split())
if a % 2 != 0:
	a = a + 1
if a + 2 > b:
	print(-1)
else:
	print(a, a + 1, a + 2)


(l, r) = map(int, input().rstrip().split(' '))
if r - l < 2:
	print(-1)
elif r - l >= 3:
	if l % 2:
		print(l + 1, l + 2, l + 3)
	else:
		print(l, l + 1, l + 2)
elif r - l == 2:
	if not l % 2:
		print(l, l + 1, r)
	else:
		print(-1)


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
(L, R) = map(int, input().split())
R += 1

def solve():
	for a in range(L, R):
		for b in range(a + 1, R):
			for c in range(b + 1, R):
				if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
					return str(a) + ' ' + str(b) + ' ' + str(c)
	return -1
print(solve())


(l, r) = map(int, input().split())
if r - l + 1 < 3:
	print(-1)
elif l % 2 == 0:
	print(f'{l} {l + 1} {l + 2}')
elif r - l + 1 > 3:
	print(f'{l + 1} {l + 2} {l + 3}')
else:
	print(-1)


(n, l) = list(map(int, input().split()))
if n % 2 != 0:
	n += 1
if l - n < 2:
	print(-1)
else:
	print(n, n + 1, n + 2)


def gcd(x, y):
	if min(x, y) == 0:
		return max(x, y)
	else:
		return gcd(min(x, y), max(x, y) % min(x, y))
(a, b) = map(int, input().split())
if abs(a - b) < 2:
	print(-1)
else:
	flag = c = 0
	if a % 2 == 1:
		a += 1
	if b % 2 == 1:
		b -= 1
	for i in range(a + 1, b):
		if gcd(a, i) == 1 and gcd(b, i) == 1:
			c = i
			flag = 1
			break
	if flag == 1:
		print(a, c, b)
	else:
		print(-1)


def gcd(a, b):
	while a != 0:
		(a, b) = (b % a, a)
	return b
(l, r) = map(int, input().split())
F = False
ans = []
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(i + 1, j):
			if gcd(i, k) == gcd(j, k) == 1 and gcd(i, j) != 1:
				F = True
				ans = str(i) + ' ' + str(k) + ' ' + str(j)
if not F:
	print(-1)
else:
	print(ans)


(l, r) = (int(x) for x in input().split())
l += l % 2
if r - l < 2:
	print(-1)
else:
	print(l, l + 1, l + 2)


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

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

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

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
(l, r) = invr()
for i in range(l, r - 1):
	a = i
	b = i + 1
	c = i + 2
	if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(c, a) != 1):
		print(a, b, c)
		sys.exit()
print(-1)


import math
l = 0
r = 0
(l, r) = input().split()
l = int(l)
r = int(r)
isab = False
isbc = False
noac = False
success = False
A = l
B = l
C = l
i = l
while A <= r:
	B = A + 1
	while B <= r:
		if B == A:
			B += 1
			continue
		if math.gcd(A, B) == 1:
			isab = True
			C = B + 1
			while C <= r:
				if C == A or C == B:
					C += 1
					continue
				if math.gcd(C, B) == 1:
					isbc = True
					if math.gcd(A, C) != 1:
						noac = True
						break
				C += 1
		if isab and isbc and noac:
			success = True
			break
		B += 1
	if isab and isbc and noac:
		success = True
		break
	A += 1
if success:
	print(A, B, C)
else:
	print(-1)


import math
(n, m) = map(int, input().split())
l1 = [(a, b, c) for a in range(n, m + 1) for b in range(a + 1, m + 1) for c in range(b + 1, m + 1) if math.gcd(a, b) == 1 and math.gcd(b, c) == 1 and (math.gcd(c, a) != 1)]
if len(l1) == 0:
	print('-1')
else:
	for j in l1[0]:
		print(j, end=' ')


(n, m) = map(int, input().split())
if n % 2 != 0:
	n = n + 1
if n + 2 > m:
	print(-1)
else:
	print(n, n + 1, n + 2)


(l, r) = map(int, input().split())
if r - l >= 2:
	if r - l == 2:
		if l % 2 == 0:
			print(l, l + 1, l + 2)
		else:
			print(-1)
	else:
		for i in range(l, r + 1):
			if i % 2 == 0:
				print(i, i + 1, i + 2)
				break
else:
	print(-1)


import math
(l, r) = map(int, input().rstrip().split())
con1 = True
for i1 in range(l, r + 1):
	if not con1:
		break
	for j1 in range(l + 1, r + 1):
		if math.gcd(i1, j1) > 1 and i1 != j1:
			l1 = i1
			r1 = j1
			con1 = False
			break
if con1:
	print(-1)
if not con1:
	result = [l1, r1]
	for i in range(l1 + 1, r1):
		if math.gcd(i, l1) == 1 and math.gcd(i, r1) == 1:
			result.insert(1, i)
			break
	print(*result)


(l, r) = map(int, input().split())
l += l % 2
if l + 2 > r:
	print(-1)
else:
	print(l, l + 1, l + 2)


(l, r) = map(int, input().split())
if r - l < 2 or (r - l == 2 and r % 2 == 1):
	print(-1)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


import math
(l, r) = map(int, input().split())
if r - l == 0 or r - l == 1:
	print('-1')
elif r - l == 2:
	if l % 2 == 0:
		print(l, l + 1, l + 2)
	else:
		print('-1')
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r) = map(int, input().split())
a = b = c = -1
result = False
for i in range(l, r - 1):
	for j in range(i + 1, r):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == gcd(j, k) == 1:
				if gcd(i, k) > 1:
					result = True
					(a, b, c) = (i, j, k)
					break
		if result:
			break
	if result:
		break
if a + b + c > 0:
	print(a, b, c)
else:
	print(-1)


(a, b) = map(int, input().split())

def gcd(a, b):
	while b % a != 0:
		t = a
		a = b % a
		b = t
	return a
f = 0
for i in range(a, b):
	for j in range(i + 2, b + 1):
		if gcd(i + 1, j) == 1 and gcd(i, j) != 1:
			f = 1
			print(i, i + 1, j)
			break
	if f == 1:
		f = 2
		break
if f == 0:
	print(-1)


import math
(l, r) = map(int, input().split())
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			a = i
			b = j
			c = k
			if math.gcd(a, b) == 1 and math.gcd(b, c) == 1:
				if math.gcd(a, c) != 1:
					print(a, b, c)
					exit()
print(-1)


(a, b) = map(int, input().split())
if abs(a - b) < 2:
	print(-1)
elif a % 2 == 0:
	print(a, a + 1, a + 2)
elif b - a >= 3:
	print(a + 1, a + 2, a + 3)
else:
	print(-1)


from itertools import combinations
from math import gcd
(l, r) = map(int, input().split())
for (a, b, c) in combinations(range(l, r + 1), 3):
	if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
		print(a, b, c)
		exit()
print(-1)


from math import gcd
(a, b) = map(int, input().split())
c = 0
d = 0
for i in range(a, b + 1):
	c += 1
	if d == 0:
		for j in range(1, b - a + 1 - c):
			if d == 0:
				for k in range(0, b - a + 1 - c):
					if gcd(i, i + j) == 1 and gcd(i + j, b - k) == 1 and (gcd(i, b - k) != 1):
						print(f'{i} {i + j} {b - k}')
						d += 1
						break
if d == 0:
	print('-1')


(l, r) = list(map(int, input().split(' ')))
if l % 2 != 0:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print('{} {} {}'.format(l, l + 1, l + 2))


(l, r) = map(int, input().split())
if r - l < 2 or (r - l == 2 and l % 2 == 1):
	print(-1)
else:
	if l % 2 == 1:
		l += 1
	print(l, l + 1, l + 2)


(l, r) = [int(_) for _ in input().split()]
if l % 2 != 0:
	l += 1
if r - l < 2:
	print(-1)
else:
	print(l, l + 1, l + 2)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l, r) = [int(x) for x in input().split()]
for a in range(l, r + 1):
	for b in range(a + 1, r + 1):
		for c in range(b + 1, r + 1):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				print(a, b, c)
				exit()
print(-1)


from fractions import gcd

def checkok(a, b, c):
	if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
		return True
	return False
mark = False
(l, r) = map(int, input().split(' '))
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			if checkok(i, j, k) and (not mark):
				print(i, j, k)
				mark = True
if not mark:
	print(-1)


from math import gcd
(l, r) = map(int, input().split())
flag = 0
t = -1
if abs(l - r) + 1 < 3:
	print(-1)
else:
	for i in range(l, r - 1):
		f = i
		s = i + 1
		for j in range(i + 2, r + 1):
			if gcd(j, f) != 1 and gcd(j, s) == 1:
				t = j
				flag = 1
				break
		if flag:
			break
	if t == -1:
		print(-1)
	else:
		print(f, s, t)


def inp():
	return map(int, input().split())
import math as m
(l, r) = inp()
if r - l < 2:
	exit(print(-1))
if l % 2 == 0:
	exit(print(l, l + 1, l + 2, sep=' '))
if l % 2 != 0 and r - l > 2:
	print(l + 1, l + 2, l + 3, sep=' ')
else:
	print(-1)


a = input().split()
l = int(a[0])
r = int(a[1])
if l % 2 == 0:
	if r - l >= 2:
		print(l, l + 1, l + 2)
	else:
		print(-1)
if l % 2 != 0:
	if r - l >= 3:
		print(l + 1, l + 2, l + 3)
	else:
		print(-1)


import math
(l, r) = map(int, input().split())
flag = 0
for j in range(r - l + 1):
	a = l + j
	b = l + j + 1
	for i in range(1, r - l):
		if math.gcd(a, b) == 1 and (math.gcd(b, b + i) == 1 and math.gcd(a, b + i) != 1) and (b + i <= r):
			c = b + i
			print(a, b, c)
			flag = 1
			break
	if flag == 1:
		break
else:
	print(-1)


def coprime(value1, value2):
	while value1 != 0 and value2 != 0:
		if value1 > value2:
			value1 %= value2
		else:
			value2 %= value1
	if max(value1, value2) == 1:
		return 1
	else:
		return 0
a = list(map(int, input().strip().split()))[:2]
fir = a[0]
sec = a[0] + 1
trd = a[1]
if trd - fir <= 1:
	print(-1)
else:
	for f in range(fir, trd + 1):
		for i in range(sec, trd + 1):
			if coprime(i, f) == 0:
				continue
			for j in range(sec + 1, trd + 1):
				if coprime(j, i) == 0:
					continue
				if coprime(j, f) == 0 and f <= i <= j:
					print(f, i, j)
					exit()
	print(-1)


from math import gcd
(l, r) = map(int, input().split())
init = l
x = l
a = init
b = 0
c = 0
while l <= x <= r and l <= init <= r:
	if gcd(x, init) == 1 and b == 0:
		b = x
		init = b
		x = b
	if gcd(x, init) == 1 and b != 0 and (c == 0):
		c = x
		if gcd(a, c) == 1:
			c = 0
		else:
			break
	if x == r:
		if b == 0 or c == 0:
			init = a + 1
			x = init
			a = init
			c = 0
			b = 0
			continue
	x += 1
if a != 0 and b != 0 and (c != 0):
	print(a, b, c)
else:
	print(-1)


(l, r) = [int(x) for x in input().split()]
if l % 2 != 0:
	l += 1
if abs(l - r) < 2:
	print('-1')
else:
	print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))


R = lambda : map(int, input().split())
(l, r) = R()
if l % 2:
	l += 1
if r - l >= 2:
	print(l, l + 1, l + 2)
else:
	print(-1)


def nod(x, y):
	while min(x, y) > 0 and x != y:
		if x > y:
			x = x % y
		else:
			y = y % x
	return max(x, y)

def is_me_right(left, right):
	for a in range(l, r - 1):
		for b in range(a + 1, r):
			for c in range(b + 1, r + 1):
				if nod(a, b) == 1 and nod(b, c) == 1 and (nod(a, c) != 1):
					return (True, a, b, c)
	return (False, 1, 1, 1)
(l, r) = list(map(int, input().split()))
(imr, a, b, c) = is_me_right(l, r)
if imr:
	print(a, b, c)
else:
	print(-1)


(l, r) = map(int, input().split())
if r - l <= 1:
	print(-1)
	exit()
else:
	if l == 1:
		if r - l == 2:
			print(-1)
			exit()
		else:
			print(2, 3, 4)
			exit()
	if l % 2 == 0:
		print(l, l + 1, l + 2)
	elif r - l == 2:
		print(-1)
		exit()
	else:
		print(l + 1, l + 2, l + 3)


import math
(l, r) = [int(x) for x in input().split(' ')]
if r - l < 2:
	print(-1)
	quit()

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
for a in range(l, r + 1):
	for b in range(a + 1, r + 1):
		for c in range(b + 1, r + 1):
			if gcd(a, c) != 1 and gcd(b, c) == 1:
				print(a, b, c)
				quit()
print(-1)


(l, r) = map(int, input().strip().split(' '))
ran = r - l + 1
if ran < 3 or (l % 2 == 1 and ran < 4):
	print('-1')
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


(l, r) = map(int, input().split())

def gcd(x, y):
	while y != 0:
		(x, y) = (y, x % y)
	return x
for a in range(l, r + 1):
	for b in range(a + 1, r + 1):
		for c in range(b + 1, r + 1):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				print(a, b, c)
				exit()
print(-1)


(x, y) = map(int, input().split())
if x % 2 != 0:
	x += 1
if abs(y - x) < 2:
	print('-1')
else:
	print(x, x + 1, x + 2)


from fractions import gcd

def main():
	(l, r) = map(int, input().split(' '))
	for a in range(l, r - 1):
		b = a + 1
		for c in range(b + 1, r + 1):
			if gcd(b, c) == 1 and gcd(a, c) != 1:
				return '{} {} {}'.format(a, b, c)
	return -1
print(main())


def hcf(a, b):
	remainder = b % a
	if remainder == 0:
		return a
	return hcf(remainder, a)
(l, r) = list(map(int, input().split()))
coprime = {}
for n1 in range(l, r, 1):
	for n2 in range(n1 + 1, r + 1, 1):
		if hcf(n1, n2) == 1:
			existing = coprime.get(n1, [])
			existing.append(n2)
			coprime[n1] = existing
results = None
for a in coprime.keys():
	coprime_with_a = coprime[a]
	for b in coprime_with_a:
		for c in coprime.get(b, []):
			if c not in coprime_with_a:
				results = [a, b, c]
				results.sort()
				break
if results is not None:
	print(results[0], results[1], results[2])
else:
	print(-1)


def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
(a, b) = map(int, input().split())
ones = []
result = []
for i in range(a, b):
	if gcd(i, i + 1) == 1:
		ones.append((i, i + 1))
for j in range(len(ones) - 1):
	if ones[j][1] == ones[j + 1][0]:
		if gcd(ones[j][0], ones[j + 1][1]) != 1:
			result.append(ones[j][0])
			result.append(ones[j][1])
			result.append(ones[j + 1][1])
			break
if len(result) < 3:
	print(-1)
else:
	print(*result)


(l, r) = [int(i) for i in input().split()]
if r - l < 2:
	print(-1)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
elif r - l > 2:
	print(l + 1, l + 2, l + 3)
else:
	print(-1)


import sys
from math import *
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
ls = lambda : list(input().strip())
from collections import defaultdict as df
import heapq
infinite = float('inf')
(l, r) = RI()
if l % 2 != 0:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))


(l, r) = map(int, input().split())

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
x = y = z = 0
for i in range(l, r):
	x = i
	y = i + 1
	for j in range(l + 2, r + 1):
		if gcd(y, j) == 1 and gcd(x, j) != 1:
			z = j
			break
	if z:
		break
if z:
	print(x, y, z)
else:
	print('-1')


from math import gcd
(l, r) = list(map(int, input().split()))
if r - l == 1:
	print(-1)
else:
	x = l
	while True:
		if x + 2 > r:
			break
		a = x
		b = x + 1
		c = x + 2
		if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
			print(a, b, c)
			exit()
		x += 1
	print(-1)


def parse(st):
	return list(map(int, st.split()))

def solve(l, r):
	if l % 2 != 0:
		l += 1
	if l + 2 > r:
		return '-1'
	else:
		return '{} {} {}'.format(l, l + 1, l + 2)
(l, r) = parse(input())
res = solve(l, r)
print(res)


from math import gcd, sqrt

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

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

def li():
	return list(mi())

def si():
	return input()
(l, r) = mi()

def isprime(n):
	if n <= 1:
		return 0
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0:
			return 0
	return 1
i = 1
b = []
while 1:
	if isprime(i):
		b.append(i)
	i += 1
	if len(b) == 50:
		break
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			(f, f1, f2) = (0, 1, 1)
			for k2 in b:
				if i % k2 == 0 and k % k2 == 0:
					f = 1
				if i % k2 == 0 and j % k2 == 0:
					f1 = 0
				if k % k2 == 0 and j % k2 == 0:
					f2 = 0
			if f1 * f2:
				if f:
					print(i, j, k)
					exit()
print('-1')


t = 1
for _ in range(t):
	(n, m) = map(int, input().split())
	if n & 1:
		n += 1
	if n + 2 > m:
		print(-1)
	else:
		print(n, n + 1, n + 2)


import os
import sys
from io import BytesIO, IOBase
import math

def main():
	(l, r) = map(int, input().split(' '))
	chk = 0
	for a in range(l, r + 1):
		for x in range(a + 1, r + 1):
			if math.gcd(a, x) == 1:
				for y in range(x + 1, r + 1):
					if math.gcd(a, y) != 1 and math.gcd(x, y) == 1:
						chk = 1
						aa = a
						bb = x
						cc = y
						break
	if chk == 0:
		print(-1)
	else:
		print(aa, bb, cc)
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()


import math
d = [3, 5, 7, 11, 13, 17, 19, 23]
(n, m) = input().split()
n = int(n)
m = int(m)
if m - n < 2:
	print(-1)
elif n % 2 == 0:
	print(n, ' ', n + 1, ' ', n + 2)
elif m - n > 2:
	print(n + 1, ' ', n + 2, ' ', n + 3)
else:
	f = 0
	for i in d:
		if n % i == 0 and n + 2 * i <= m:
			f = 1
			print(n, ' ', n + 1, ' ', n + 2 * i)
	if ~f:
		print(-1)


import os
import sys
from math import gcd
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')
readint = lambda : int(sys.stdin.readline().rstrip('\r\n'))
readints = lambda : map(int, sys.stdin.readline().rstrip('\r\n').split())
readstr = lambda : sys.stdin.readline().rstrip('\r\n')
readstrs = lambda : map(str, sys.stdin.readline().rstrip('\r\n').split())
readarri = lambda : [int(_) for _ in sys.stdin.readline().rstrip('\r\n').split()]
readarrs = lambda : [str(_) for _ in sys.stdin.readline().rstrip('\r\n').split()]

def solve():
	(l, r) = readints()
	if r - l <= 2:
		if r - l <= 1:
			print(-1)
		elif gcd(l, r) != 1:
			print(l, l + 1, l + 2)
		else:
			print(-1)
	elif not l & 1:
		print(l, l + 1, l + 2)
	else:
		start = l + 2
		while 1:
			if start > r:
				l += 1
				start = l + 2
			if gcd(l + 1, start) == 1 and gcd(l, start) != 1:
				print(l, l + 1, start)
				break
			start += 1

def main():
	t = 1
	for _ in range(t):
		solve()
main()


from fractions import gcd
(l, r) = map(int, input().split())
a = l
b = l
c = l
for i in range(l, r + 1):
	for j in range(l + 1, r + 1):
		for k in range(l + 2, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1) and (i != k):
				print(i, j, k)
				exit()
print(-1)


def gcd(a, b):
	mini = min(a, b)
	maxi = max(a, b)
	while maxi % mini != 0:
		temp = mini
		mini = maxi % mini
		maxi = temp
	return mini
l_r = list(map(int, input().split(' ')))
(l, r) = l_r
lis = ()
flag = 0
for i in range(l, r - 1):
	for j in range(i + 1, r):
		if gcd(i, j) == 1:
			for k in range(j + 1, r + 1):
				if gcd(j, k) == 1 and gcd(i, k) != 1:
					lis = (i, j, k)
					flag = 1
					break
			if flag:
				break
	if flag:
		break
if lis:
	print(*lis)
else:
	print(-1)


from sys import stdin, stdout, exit
import math
from fractions import gcd

def sin():
	return stdin.readline().rstrip()

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
(l, r) = listInput()
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				print(i, j, k)
				exit(0)
print(-1)


(x, y) = input().split()
(a, b) = (int(x), int(y))
if a % 2 == 0 and a + 2 <= b:
	print(a, a + 1, a + 2)
elif a % 2 != 0 and a + 3 <= b:
	print(a + 1, a + 2, a + 3)
else:
	print('-1')


X = list(map(int, input().split()))
if X[1] - X[0] < 2 + X[0] % 2:
	print(-1)
	exit()
if X[0] % 2 == 0:
	print(X[0], X[0] + 1, X[0] + 2)
else:
	print(X[0] + 1, X[0] + 2, X[0] + 3)


import sys
(l, r) = map(int, sys.stdin.readline().split())
if r - l <= 1:
	print(-1)
elif r - l == 2:
	if l % 2 == 1:
		print(-1)
	else:
		print(l, l + 1, l + 2)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


(l, r) = [int(i) for i in input().split()]
while l <= r - 2:
	if l % 2:
		l += 1
	else:
		print(*[l, l + 1, l + 2])
		break
else:
	print(-1)


(l, r) = map(int, input().split())
import math
import sys
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			if math.gcd(i, j) == 1 and math.gcd(j, k) == 1 and (math.gcd(i, k) != 1):
				print(i, j, k)
				sys.exit()
print(-1)


def counterexample(a, b):
	if b - a > 2:
		if a % 2 == 0:
			print(a, a + 1, a + 2)
			return
		else:
			print(a + 1, a + 2, a + 3)
			return
	if b - a == 2:
		if a % 2 == 0:
			print(a, a + 1, a + 2)
			return
		else:
			print(-1)
			return
	else:
		print(-1)
		return
(a, b) = list(map(int, input().split(' ')))
counterexample(a, b)


(x, z) = map(int, input().split())
a = 0
b = 0
c = 0
if z - x <= 1:
	print(-1)
	exit()
for i in range(x, z + 1):
	if a == 0:
		for j in range(x, z + 1):
			if j % 2 == 0:
				a = j
				break
	else:
		b = a + 1
		c = b + 1
		break
if a == 0 or b == 0 or c == 0:
	print(-1)
elif b >= z or c > z:
	print(-1)
else:
	print(a, b, c)


numbers = [int(x) for x in input().split()]
if numbers[0] % 2 != 0:
	numbers[0] += 1
if abs(numbers[0] - numbers[1]) < 2:
	print('-1')
else:
	print(numbers[0], numbers[0] + 1, numbers[0] + 2)


import sys, math
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
(l, r) = invr()
a = l
if l % 2:
	a += 1
b = a + 1
c = b + 1
if a >= l and c <= r:
	print(str(a) + ' ' + str(b) + ' ' + str(c))
else:
	print(-1)


import math
import random
(n, m) = map(int, input().split())
flag = 0
f = 0
if m - n == 1 or m - n == 0:
	print(-1)
elif m - n == 2:
	if math.gcd(n, n + 1) == 1 and math.gcd(n + 1, m) == 1 and (math.gcd(n, m) != 1):
		print(n, n + 1, m)
	else:
		print(-1)
else:
	while True:
		if math.gcd(n, m) != 1:
			break
		elif n % 2 == 0 and m % 2 != 0:
			m = m - 1
		elif m % 2 == 0 and n % 2 != 0:
			n = n + 1
		elif m % 2 != 0 and n % 2 != 0:
			m = m - 1
			n = n + 1
	i = n + 1
	while True:
		if math.gcd(n, i) == 1 and math.gcd(i, m) == 1:
			print(n, i, m)
			break
		else:
			i = i + 1


(a, b) = map(int, input().split())
if b - a >= 2:
	if a % 2 == 1 and b - a == 2:
		print(-1)
	elif a % 2 == 1:
		print(a + 1, a + 2, a + 3)
	else:
		print(a, a + 1, a + 2)
else:
	print(-1)


(a, b) = map(int, input().split())
if b - a <= 1:
	print(-1)
	exit()
if a % 2 == 1:
	if b - a > 2:
		print(a + 1, a + 2, a + 3)
	else:
		print(-1)
else:
	print(a, a + 1, a + 2)


x = []
x.extend(input().split())
l = int(x[0])
r = int(x[1])
if l + 2 > r:
	print(-1)
elif l + 2 == r and l % 2 == 1:
	print(-1)
else:
	if l % 2 == 1:
		l = l + 1
	print(l, l + 1, l + 2)


import math
buff = input().split(' ')
l = int(buff[0])
r = int(buff[1])
res = []
for a in range(l, r - 1):
	for b in range(a + 1, r):
		for c in range(b, r + 1):
			if math.gcd(a, b) == 1 and math.gcd(b, c) == 1 and (math.gcd(a, c) != 1):
				res = [a, b, c]
				break
if res == []:
	print(-1)
else:
	print(res[0], res[1], res[2])


(start, finish) = map(int, input().split())
(a, b, c) = (0, 0, 0)
if start & 1 == 0 and finish - start >= 2:
	print(start, start + 1, start + 2)
elif start & 1 == 1 and finish - start >= 3:
	print(start + 1, start + 2, start + 3)
else:
	print(-1)


def judge(a, b):
	while a > 1:
		(b, a) = (a, b % a)
	return a

def search(l, r):
	for i in range(l, r + 1):
		for j in range(i + 1, r + 1):
			for k in range(j + 1, r + 1):
				if judge(i, j) and judge(j, k) and (not judge(i, k)):
					print(i, j, k)
					return
	print(-1)
	return
(l, r) = [int(i) for i in input().split()]
search(l, r)


import math
(n, m) = input().split()
n = int(n)
m = int(m)
founded = False
fN = 0
sN = 0
tN = 0
for x in range(n, m + 1):
	for y in range(x + 1, m + 1):
		for z in range(x + 2, m + 1):
			if math.gcd(x, y) == 1 and math.gcd(y, z) == 1 and (math.gcd(x, z) != 1):
				fN = x
				sN = y
				tN = z
				founded = True
				break
		if founded:
			break
	if founded:
		break
if founded:
	print(fN, sN, tN)
else:
	print(-1)


(n, m) = map(int, input().split())
if n % 2 == 0:
	if m - n < 2:
		print(-1)
	else:
		print('{0} {1} {2}'.format(n, n + 1, n + 2))
elif m - n < 3:
	print(-1)
else:
	print('{0} {1} {2}'.format(n + 1, n + 2, n + 3))


(z, x) = [int(c) for c in input().split()]
while 1:
	if z + 2 <= x:
		if z % 2 == 0:
			print('%d %d %d' % (z, z + 1, z + 2))
			break
		else:
			z += 1
	else:
		print(-1)
		break


from math import gcd
(l, r) = map(int, input().split())
if r - l + 1 < 3:
	print(-1)
elif l % 2 == 0:
	print('{} {} {}'.format(l, l + 1, l + 2))
elif r - l + 1 > 3:
	print('{} {} {}'.format(l + 1, l + 2, l + 3))
else:
	print(-1)


def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
(l, r) = map(int, input().split())
rip = True
if r - l < 2:
	print(-1)
else:
	for j in range(l, r - 1):
		for i in range(j + 2, r + 1):
			if gcd(i, j + 1) == 1 and gcd(j, i) != 1:
				print(j, j + 1, i)
				rip = False
				break
		if not rip:
			break
	if rip:
		print(-1)


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

def are_coprimes(a, b):
	return gcd(a, b) == 1
(l, r) = [int(x) for x in input().split()]
found = False
a = b = c = 0
for i in range(l, r - 1):
	for j in range(i + 1, r):
		if are_coprimes(i, j):
			for k in range(j + 1, r + 1):
				if are_coprimes(j, k) and (not are_coprimes(i, k)):
					found = True
					break
		if found:
			break
	if found:
		break
if not found:
	print(-1)
else:
	print(i, j, k)


(l1, r1) = input().split()
l = int(l1)
r = int(r1)
if l % 2 == 0 and r - l >= 2:
	print(l, l + 1, l + 2)
elif l % 2 == 1 and r - l >= 3:
	print(l + 1, l + 2, l + 3)
else:
	print(-1)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

def read_ints():
	return [int(x) for x in stdin.readline().split()]

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
(a, b) = read_ints()
a += a % 2
ans = [-1]
if a + 2 <= b:
	ans = [a, a + 1, a + 2]
print(*ans)


import sys
import math as m

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l
mod = int(1000000000.0) + 7

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

def iinp():
	return int(input())

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

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

def p(a):
	print(a)

def p2(a, b):
	print(a, b)
(l, r) = ninp()
if r - l <= 1:
	print(-1)
elif r - l == 2:
	if l % 2 == 0:
		print(l, l + 1, l + 2)
	else:
		print(-1)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


from math import sqrt
(n, m) = tuple(map(int, input().split()))
if m <= n + 1:
	print('-1')
	exit()
res = '-1'
if n % 2 == 0 and m >= n + 2:
	res = str(n) + ' ' + str(n + 1) + ' ' + str(n + 2)
elif m >= n + 3:
	res = str(n + 1) + ' ' + str(n + 2) + ' ' + str(n + 3)
else:
	if m <= n + 2:
		print('-1')
		exit()
	coso = 0
	for i in range(2, n + 1):
		if not n % i and n % 2:
			coso = i
			break
	if not coso:
		print('-1')
		exit()
	for i in range(n + 2, m):
		if i % coso == 0:
			res = res = str(n) + ' ' + str(n + 1) + ' ' + str(i)
print(res)


a = list(map(int, input().split()))
(l, r) = (a[0], a[1])
if r - l < 2:
	print(-1)
elif r - l == 2 and l % 2 != 0:
	print(-1)
elif l % 2 == 0:
	print(str(l), str(l + 1), str(l + 2))
else:
	print(str(l + 1), str(l + 2), str(l + 3))


x = [int(item) for item in input().split()]
if x[1] - x[0] > 2:
	if x[0] % 2 == 0:
		print(str(x[0]) + ' ' + str(x[0] + 1) + ' ' + str(x[0] + 2))
	else:
		print(str(x[0] + 1) + ' ' + str(x[0] + 2) + ' ' + str(x[0] + 3))
elif x[1] - x[0] == 2:
	if x[0] % 2 != 0:
		print(-1)
	else:
		print(str(x[0]) + ' ' + str(x[0] + 1) + ' ' + str(x[1]))
else:
	print(-1)


__author__ = 'neki'
import sys
words = input().split()
l = int(words[0])
r = int(words[1])
if r - l <= 1:
	print(-1)
elif r - l == 2:
	if l % 2 == 0:
		print(l, l + 1, l + 2)
	else:
		print(-1)
elif r - l >= 3:
	a = l
	if a % 2 == 1:
		a += 1
	b = a + 1
	c = a + 2
	print(a, b, c)


(left, right) = map(int, input().split())
distance = right - left + 1
if distance > 3:
	if left % 2 == 0:
		print(left, left + 1, left + 2)
	else:
		print(left + 1, left + 2, left + 3)
elif distance == 3:
	if left % 2 == 0:
		print(left, left + 1, left + 2)
	else:
		print(-1)
else:
	print(-1)


def solve(l, r):
	if r - l + 1 < 3:
		print(-1)
		return
	if l % 2 == 0:
		print(l, end=' ')
		print(l + 1, end=' ')
		print(l + 2)
		return
	if r - l + 1 > 3:
		print(l + 1, end=' ')
		print(l + 2, end=' ')
		print(l + 3)
		return
	print(-1)
(l, r) = map(int, input().split())
solve(l, r)


import math

def main():
	(n, m) = map(int, input().split())
	for i in range(n, m + 1):
		for j in range(i + 1, m + 1):
			for k in range(j + 1, m + 1):
				if math.gcd(i, j) == 1 and math.gcd(j, k) == 1 and (math.gcd(i, k) != 1):
					print(i, j, k)
					return
	print(-1)
main()


from fractions import gcd
raw = input()
raw = raw.split(' ')
raw = [int(x) for x in raw]
flag = 0
for x in range(raw[0], raw[1] - 1):
	if flag == 1:
		break
	for y in range(x + 1, raw[1]):
		if flag == 1:
			break
		if gcd(x, y) == 1:
			for z in range(y + 1, raw[1] + 1):
				if gcd(y, z) == 1:
					if gcd(x, z) != 1:
						print(x, y, z)
						flag = 1
						break
if flag == 0:
	print(-1)


import math
(a, b) = [int(i) for i in input().split()]
z = -1
otv = str()
for i in range(a, b - 1):
	for n in range(i, b):
		for g in range(n, b + 1):
			if math.gcd(i, n) == 1 and math.gcd(n, g) == 1 and (math.gcd(g, i) != 1):
				z = 1
				otv = str(i) + ' ' + str(n) + ' ' + str(g)
				break
		if z == 1:
			break
	if z == 1:
		break
if z == -1:
	print(z)
else:
	print(otv)


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

def isCoprime(a, b):
	if gcd(a, b) == 1:
		return True
	else:
		return False

def main():
	(l, r) = map(int, input().split())
	for a in range(l, r - 1):
		for b in range(a + 1, r):
			if isCoprime(a, b) == True:
				for c in range(b + 1, r + 1):
					if isCoprime(b, c) == True:
						if isCoprime(a, c) == False:
							print(a, b, c)
							return
	print(-1)
	return

def __starting_point():
	main()
__starting_point()


def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def solve(l, r):
	for i in range(l, r + 1):
		for j in range(i, r + 1):
			for k in range(j, r + 1):
				if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
					return [i, j, k]
	return [-1]
(l, r) = map(int, input().split())
found = False
ans = solve(l, r)
if len(ans) == 1:
	print(-1)
else:
	print(ans[0], ans[1], ans[2])


(l, r) = input().split()
(l, r) = (int(l), int(r))
if r - l < 2:
	print(-1)
elif r - l == 2 and l % 2 == 0:
	print(l, l + 1, r)
elif r - l == 2 and l % 2 == 1:
	print(-1)
else:
	while l % 2 == 1:
		l += 1
	print(l, l + 1, l + 2)


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

def main():
	(l, r) = map(int, input().split())
	for i in range(l, r - 1):
		if gcd(i, i + 1) == 1 and gcd(i + 1, i + 2) == 1 and (gcd(i, i + 2) != 1):
			print(i, i + 1, i + 2)
			return
	print(-1)
	return
main()


import sys
(mod, MOD) = (1000000007, 998244353)
from math import ceil, floor, log, sqrt, factorial, pi, gcd

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

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

def input():
	return sys.stdin.readline().strip()
(l, r) = get_ints()
if l & 1:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print(l, l + 1, l + 2)


import sys
(le, rg) = map(int, input().split())
rg += 1

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
for a in range(le, rg):
	for b in range(a + 1, rg):
		gab = gcd(a, b)
		if gab != 1:
			continue
		for c in range(b + 1, rg):
			if gcd(b, c) == 1 and gcd(a, c) > 1:
				print(a, b, c)
				sys.exit(0)
print(-1)


import sys
(l, r) = map(int, sys.stdin.readline().split())
if l % 2 is not 0:
	l += 1
if r - l < 2:
	print(-1)
else:
	print(l, l + 1, l + 2)


(l, r) = map(int, input().split())
if r - l + 1 < 3 or (r - l + 1 == 3 and l % 2 == 1):
	print(-1)
else:
	base = l % 2 + l
	ans = [base, base + 1, base + 2]
	print(*ans, sep=' ')


import sys
(a, b) = map(int, input().split())
if b - a <= 1:
	print(-1)
	sys.exit()
if b - a == 2 and a % 2 == 1:
	print(-1)
	sys.exit()
if a % 2 == 0:
	print(a, end=' ')
	print(a + 1, end=' ')
	print(a + 2)
else:
	print(a + 1, end=' ')
	print(a + 2, end=' ')
	print(a + 3)


import sys
import math

def gcd(a, b):
	while a != 0 and b != 0:
		if a > b:
			a = a % b
		else:
			b = b % a
	return max(a, b)

def main(n, m):
	for i in range(n, m - 1):
		for j in range(i + 1, m):
			for k in range(j + 1, m + 1):
				if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
					print(i, j, k)
					return
	print(-1)
for (e, line) in enumerate(sys.stdin.readlines()):
	(n, m) = map(int, line.strip().split())
main(n, m)


(l, r) = map(int, input().split())

def ans(l, r):
	if l % 2 != 0:
		l = l + 1
		return ans(l, r)
	elif l + 2 > r:
		return '-1'
	else:
		a = str(l) + ' ' + str(l + 1) + ' ' + str(l + 2)
		return a
print(ans(l, r))


from math import gcd
from collections import defaultdict
(l, r) = list(map(int, input().rstrip().split()))
d = defaultdict(list)
for i in range(l, r):
	for j in range(i, r + 1):
		if gcd(i, j) == 1:
			d[i].append(j)
for (i, j) in d.items():
	for k in j:
		if k in d.keys():
			for l in d[k]:
				if gcd(i, l) != 1:
					print(i, k, l)
					exit()
print(-1)


(a, b) = map(int, input().split())
superbreak = 0
for i in range(a, b + 1):
	for j in range(i + 1, b + 1):
		for k in range(j + 1, b + 1):
			(j2, i2, k2) = (j, i, k)
			lst = sorted([j, i, k])
			while j > 0:
				(i, j) = (j, i % j)
			if i == 1:
				while k > 0:
					(j2, k) = (k, j2 % k)
				if j2 == 1:
					while k2 > 0:
						(i2, k2) = (k2, i2 % k2)
					if i2 != 1:
						print(*lst)
						superbreak = 1
		if superbreak:
			break
	if superbreak:
		break
else:
	print(-1)


import math
(L, R) = map(int, input().split())
if L % 2 != 0:
	L += 1
if R - L <= 1:
	print(-1)
else:
	print(L, L + 1, L + 2)


from fractions import gcd
(l, r) = [int(x) for x in input().split()]
bye = False
for a in range(l, r - 1):
	for c in range(a + 2, r + 1):
		for b in range(a + 1, c):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				for x in [a, b, c]:
					print(x, end=' ')
				bye = True
				break
			if bye:
				break
		if bye:
			break
	if bye:
		break
if not bye:
	print(-1)


(m, r) = map(int, input().split())

def gcd(a, b):
	if a == 0:
		return b
	else:
		return gcd(b % a, a)
l = []
flag = 0
for i in range(m, r + 1):
	l.append(i)
	for j in range(i + 1, r + 1):
		if gcd(i, j) == 1:
			l.append(j)
			for k in range(j + 1, r + 1):
				if gcd(j, k) == 1:
					l.append(k)
					if gcd(i, k) != 1:
						flag = 1
						break
				if flag == 1:
					break
				if k in l:
					l.remove(k)
		if flag == 1:
			break
		if j in l:
			l.remove(j)
	if flag == 1:
		break
	if i in l:
		l.remove(i)
if flag == 1:
	print(str(l[0]) + ' ' + str(l[1]) + ' ' + str(l[2]))
else:
	print(-1)


import sys
(mod, MOD) = (1000000007, 998244353)
from math import ceil, floor, log, sqrt, factorial, pi, gcd

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

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

def input():
	return sys.stdin.readline().strip()
(l, r) = get_ints()
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				print(i, j, k)
				exit()
print(-1)


def rprime(a, b):
	while 1:
		(a, b) = sorted([a, b])
		if abs(a - b) == 1 or a == 1 or b == 1:
			return True
		elif b % a == 0 or a % (b - a) == 0 or b % (b - a) == 0:
			return False
		(a, b) = (a, b - a)
		(a, b) = sorted([a, b])
		b = b % a

def main(x, y):
	for a in range(x, y - 1):
		for i in range(a + 2, y + 1):
			if rprime(a + 1, i) and (not rprime(a, i)):
				return ' '.join([str(a), str(a + 1), str(i)])
	else:
		return -1
(a, b) = list(map(int, input().split()))
print(main(a, b))


import math
(l, r) = map(int, input().split())
isdone = False
for a in range(l, r):
	if isdone:
		break
	for b in range(a + 1, r):
		if isdone:
			break
		for c in range(b + 1, r + 1):
			if math.gcd(a, b) == 1 and math.gcd(b, c) == 1 and (math.gcd(a, c) != 1):
				print(a, b, c)
				isdone = True
				break
if not isdone:
	print(-1)


(n, m) = input().split()
n = int(n)
m = int(m)
if abs(n - m) == 1:
	print(-1)
elif abs(n - m) > 2:
	if n % 2 == 0:
		print(str(n) + ' ' + str(n + 1) + ' ' + str(n + 2))
	else:
		print(str(n + 1) + ' ' + str(n + 2) + ' ' + str(n + 3))
elif abs(n - m) == 2 and n % 2 == 0:
	print(str(n) + ' ' + str(n + 1) + ' ' + str(n + 2))
else:
	print(-1)


(l, r) = [int(x) for x in input().split()]
if l - r == -1:
	print(-1)
elif r - l + 1 > 3 and l % 2 != 0:
	print(l + 1, l + 2, l + 3)
elif r - l + 1 >= 3 and l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(-1)


import math
import heapq
from math import gcd, floor, sqrt, log

def iin():
	return int(input())

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

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

def liststr():
	return list(map(str, input().strip().split()))

def ceill(x):
	return int(x) if x == int(x) else int(x) + 1

def ceilldiv(x, d):
	x // d if x % d == 0 else x // d + 1

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

def nlargest(num, array):
	return heapq.nlargest(num, array)

def nsmallest(num, array):
	return heapq.nsmallest(num, array)

def solve():
	(a, b) = listin()
	if a % 2 != 0:
		a += 1
	if a + 2 > b:
		print(-1)
	else:
		print(a, a + 1, a + 2)
t = 1
for hula in range(t):
	solve()


import sys

def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
(l, r) = map(int, input().split())
for a in range(l, r - 1):
	for b in range(a + 1, r):
		for c in range(b + 1, r + 1):
			if gcd(a, b) == gcd(b, c) == 1 and gcd(a, c) != 1:
				print(a, b, c)
				sys.exit()
print(-1)


def cgcd(a, b):
	while a:
		(b, a) = (a, b % a)
	return b
n = list(map(int, input().split()))
a = int(n[0])
b = int(n[1])
c = 0
k = 0
for i in range(a, b - 1):
	for j in range(i + 1, b):
		for k in range(j + 1, b + 1):
			m = cgcd(i, j)
			o = cgcd(j, k)
			p = cgcd(i, k)
			if m == 1 and o == 1 and (p != 1):
				c = c + 1
				print(i, j, k)
				break
			else:
				continue
		if c >= 1:
			break
	if c >= 1:
		break
if c < 1:
	print('-1')


from sys import stdin
from math import gcd
input = stdin.buffer.readline
(l, r) = map(int, input().split())
for i in range(l, r + 1):
	for j in range(l, i):
		for k in range(l, j):
			if gcd(k, j) == gcd(j, i) != gcd(k, i):
				exit(print(k, j, i))
print(-1)


def gcd(p, q):
	while q != 0:
		(p, q) = (q, p % q)
	return p
li = list(map(int, input().split()))
l = li[0]
r = li[1]
c = False
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(max(i, j) + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				print(f'{i}', end=' ')
				print(f'{j}', end=' ')
				print(f'{k}')
				c = True
				break
		if c:
			break
	if c:
		break
if c:
	pass
else:
	print(-1)


(l, r) = map(int, input().split())
from math import gcd
ok = 0
for a in range(l, r - 1):
	for b in range(a + 1, r):
		for c in range(b + 1, r + 1):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) > 1):
				print(a, b, c)
				ok = 1
				break
		if ok:
			break
	if ok:
		break
if ok == 0:
	print(-1)


import math

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r) = [int(x) for x in input('').split()]
exists = False
for i in range(l, r + 1):
	for j in range(i, r + 1):
		for k in range(j, r + 1):
			if i == j or i == k or j == k:
				continue
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				print(i, j, k)
				exit()
print(-1)


import sys
input = sys.stdin.readline
from math import ceil, floor, factorial

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

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 swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(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
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
(l, r) = int_array()
for i in range(l, r - 1):
	for j in range(i + 1, r):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == 1:
				if gcd(j, k) == 1:
					if gcd(i, k) != 1:
						print(i, j, k)
						exit()
print(-1)


(l, r) = map(int, input().split())
if l % 2 != 0:
	l = l + 1
if abs(l - r) < 2:
	print(-1)
else:
	print(l, l + 1, l + 2)


(l, r) = map(int, input().split())
if r - l < 2:
	print(-1)
	exit()
if l % 2 == 0:
	print(l, l + 1, l + 2)
	exit()
if l % 2 == 1:
	if r - l == 2:
		print(-1)
		exit()
	print(l + 1, l + 2, l + 3)


__author__ = '-'
inData = input().strip().split(' ')
(a, b) = (int(inData[0]), int(inData[1]))
dividers = []
if abs(a - b) < 2:
	print(-1)
elif abs(a - b) == 2:
	if a % 2 == 0:
		print(a, a + 1, b)
	else:
		print(-1)
else:
	for i in range(a, b + 1):
		if i % 2 == 0:
			print(i, i + 1, i + 2)
			break


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

def is_coprime(a, b):
	return gcd(a, b) == 1

def find_counter(l, r):
	for i in range(l, r + 1):
		for j in range(i + 1, r + 1):
			for k in range(j + 1, r + 1):
				if is_coprime(i, j) and is_coprime(j, k) and (not is_coprime(i, k)):
					return '{} {} {}'.format(i, j, k)
	return -1
(l, r) = map(int, input().split())
print(find_counter(l, r))


from fractions import gcd
(l, r) = map(int, input().split())
res = []
for i in range(l, r + 1):
	res.clear()
	res.append(i)
	a = i
	for j in range(i + 1, r + 1):
		if gcd(a, j) == 1:
			res.append(j)
			a = j
			if len(res) == 3 and gcd(res[0], res[2]) > 1:
				print(' '.join(map(str, res)))
				exit(0)
print(-1)


inp = input().split()
n = int(inp[0])
k = int(inp[1])
l = []

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
flag = False
for i in range(n, k + 1):
	for j in range(i + 1, k + 1):
		for k in range(j + 1, k + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1) and (i != j) and (j != k) and (i != k):
				l.append(i)
				l.append(j)
				l.append(k)
				flag = True
				break
		if flag:
			break
	if flag:
		break
if len(l) == 0:
	l.append(-1)
for i in range(len(l)):
	print(l[i], end=' ')


from fractions import gcd
given = (int(x) for x in input().split(' '))
(l, r) = given

def simple(a, b):
	if gcd(a, b) == 1:
		return True
	else:
		return False

def search(down, up):
	d1 = down + 1
	for x in range(down + 2, up + 1):
		if simple(d1, x) and (not simple(down, x)):
			return (down, d1, x)
	else:
		return False
out = print

def main():
	if r - l < 2:
		out(-1)
		return
	(l1, r1) = (l, r)
	f = None
	while r1 - l1 >= 2:
		result = search(l1, r1)
		if result == False:
			l1 += 1
		else:
			f = True
			break
	if f == True:
		out(result[0], result[1], result[2])
	else:
		out(-1)
	return
main()


lr = input().strip().split(' ')
l = int(lr[0])
r = int(lr[1])
if l % 2 == 0:
	if r >= l + 2:
		print('{0} {1} {2}'.format(l, l + 1, l + 2))
	else:
		print(-1)
elif r <= l + 2:
	print(-1)
else:
	print('{0} {1} {2}'.format(l + 1, l + 2, l + 3))


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l, r) = map(int, input().split())
if r - l >= 2:
	f = 1
	for j in range(l, r - 1):
		for i in range(l + 2, r + 1):
			if gcd(i, j) > 1 and gcd(i, j + 1) == 1:
				f = 0
				print(j, j + 1, i)
				quit()
	if f:
		print(-1)
else:
	print(-1)


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

def inp(a, b):
	ans = []
	for i in range(a, b + 1):
		for j in range(i + 1, b + 1):
			x = gcd(i, j)
			if x == 1:
				for k in range(j + 1, b + 1):
					y = gcd(j, k)
					if y == 1:
						z = gcd(i, k)
						if z != 1:
							ans.append(i)
							ans.append(j)
							ans.append(k)
							return ans
	return -1
(a, b) = map(int, input().split())
x = inp(a, b)
if x == -1:
	print(x)
else:
	print(*x)


def gcd(a, b):
	if a == 0:
		return b
	else:
		return gcd(b % a, a)
(l, r) = map(int, input().split())
temp = 0
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		z = gcd(i, j)
		if z == 1:
			for k in range(j + 1, r + 1):
				m = gcd(j, k)
				if m == 1:
					n = gcd(i, k)
					if n == 1:
						temp = 0
					else:
						temp = 1
						break
		if temp == 1:
			break
	if temp == 1:
		break
if temp == 1:
	print(i, j, k)
else:
	print(-1)


def NOD(x, y):
	while y != 0:
		x = x % y
		(x, y) = (y, x)
	return x

def main():
	(l, r) = map(int, input().split())
	for a in range(l, r - 1):
		for b in range(a, r):
			for c in range(b, r + 1):
				if NOD(a, b) == 1 and NOD(b, c) == 1 and (NOD(a, c) != 1):
					print(a, b, c)
					return
	print(-1)
main()


import sys
import math
input = sys.stdin.readline
(l, r) = map(int, input().strip().split())
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		if math.gcd(i, j) != 1 and math.gcd(i + 1, j) == 1:
			print(i, i + 1, j)
			exit(0)
print(-1)


import math

def gcd(a, b):
	if b == 1:
		return True
	c = math.floor(a / b)
	d = a % b
	if d == 0:
		return False
	return gcd(b, d)
a = input()
(a, b) = a.strip().split(' ')
a = int(a)
b = int(b)
while a < b:
	for i in range(a + 1, b + 1):
		if not gcd(i, a):
			for j in range(a + 1, i):
				if gcd(a, j) and gcd(j, i):
					print(a, j, i)
					exit(0)
	a = a + 1
print(-1)


from fractions import gcd
(l, r) = map(int, input().split())

def ce(l, r):
	for a in range(l, r + 1):
		for b in range(a + 1, r + 1):
			for c in range(b + 1, r + 1):
				if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
					return [a, b, c]
	return [-1]
print(' '.join((str(x) for x in ce(l, r))))


from sys import stdin, stdout
input = stdin.readline
(l, r) = map(int, input().split())

def solve(l, r):
	if r >= l + 2:
		stdout.write(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))
	else:
		stdout.write('-1')
if l % 2 == 0:
	solve(l, r)
else:
	solve(l + 1, r)


from fractions import gcd
s = input().split()
l = int(s[0])
r = int(s[1])
a = 0
b = 0
c = 0
found = False
for i in range(l, r):
	for j in range(i + 1, r):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				a = i
				b = j
				c = k
				found = True
				break
		if found:
			break
	if found:
		break
if found:
	print(str(a) + ' ' + str(b) + ' ' + str(c))
else:
	print(-1)


import math
(l, r) = map(int, input().split(' '))

def solve(l, r):
	if l % 2 != 0:
		l += 1
	if l + 2 > r:
		print(-1)
		return
	print(l, l + 1, l + 2)
solve(l, r)


def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
flag = 0
(l, r) = map(int, input().split())
if r - l == 0:
	print(-1)
else:
	for i in range(l, r + 1):
		for j in range(i + 1, r + 1):
			if GCD(i, j) == 1:
				for k in range(j + 1, r + 1):
					if GCD(k, i) > 1 and GCD(k, j) == 1:
						flag = 1
						print(i, j, k)
						break
				if flag:
					break
		if flag:
			break
	else:
		print(-1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		(l, r) = LI()
		if l % 2 == 1:
			l += 1
		if r - l < 2:
			return -1
		rr.append(JA([l, l + 1, l + 2], ' '))
	return JA(rr, '\n')
print(main())


def gcd(a, b):
	rem = 0
	while b != 0:
		rem = a % b
		a = b
		b = rem
	return a
(a, b) = map(int, input().split())
if b - a == 1:
	print(-1)
else:
	found = False
	for i in range(a, b + 1):
		for j in range(i + 1, b + 1):
			for k in range(j + 1, b + 1):
				if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
					found = True
					print(i, j, k)
					break
			if found:
				break
		if found:
			break
	if not found:
		print(-1)


def gcd(a, b):
	if a % b == 0:
		return b
	return gcd(b, a % b)
(l, r) = map(int, input().split())
for a in range(l, r + 1):
	for b in range(a + 1, r + 1):
		if gcd(a, b) > 1:
			continue
		for c in range(b + 1, r + 1):
			if gcd(b, c) > 1:
				continue
			if gcd(a, c) > 1:
				print(' '.join(map(str, [a, b, c])))
				exit()
print('-1')


import sys
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('Yes')

def NO():
	print('No')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(l, r) = RI()
if r - l + 1 < 3:
	print(-1)
elif r - l + 1 == 3:
	if l % 2 == 1:
		print(-1)
	else:
		print(l, l + 1, l + 2)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	print(l + 1, l + 2, l + 3)


(n, m) = map(int, input().split())
if abs(n - m) == 1 or abs(n - m) == 0:
	print(-1)
elif n % 2 != 0:
	n += 1
	if n + 2 > m:
		print(-1)
	else:
		print(n, n + 1, n + 2)
else:
	print(n, n + 1, n + 2)


from fractions import gcd
(l, r) = map(int, input().split())
if r - l < 2 or (l % 2 != 0 and r - l == 2):
	print(-1)
else:
	print(l + (l % 2 != 0), l + 1 + (l % 2 != 0), l + 2 + (l % 2 != 0))


from sys import stdin
from fractions import gcd
lines = list([_f for _f in stdin.read().split('\n') if _f])

def parseline(line):
	return list(map(int, line.split()))
lines = list(map(parseline, lines))
(l, r) = lines[0]
for a in range(l, r + 1):
	for b in range(a, r + 1):
		for c in range(b, r + 1):
			if gcd(a, b) == gcd(b, c) == 1 != gcd(a, c):
				print(a, b, c)
				return
print(-1)


import math

def check(l, r):
	lt = []
	for i in range(l, r):
		for j in range(i + 1, r):
			if math.gcd(i, j) == 1:
				for k in range(j + 1, r):
					if math.gcd(j, k) == 1:
						if math.gcd(i, k) != 1:
							return [i, j, k]
	return lt
lt = list(input().split())
lt = check(int(lt[0]), int(lt[1]) + 1)
if len(lt) == 0:
	print(-1)
else:
	for i in lt:
		print(i, end=' ')


from math import *
[l, r] = [int(x) for x in input().split(' ')]
l = list(range(l, r + 1))
flag = False
a = 0
b = 0
c = 0
for a in l[:]:
	if flag:
		break
	t = l.index(a)
	for b in l[t + 1:]:
		if flag:
			break
		s = l.index(b)
		for c in l[s + 1:]:
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				flag = True
				break
if flag:
	print(a - 1, b - 1, c)
else:
	print(-1)


(n, m) = map(int, input().split())
if n % 2 == 1 and m - n == 2:
	print(-1)
elif m - n <= 1:
	print(-1)
elif n % 2 == 0:
	print(n, n + 1, n + 2)
elif n % 2 == 1:
	print(n + 1, n + 2, n + 3)


(s, e) = [int(num) for num in input().split()]

def GCD(a, b):
	return GCD(b, a % b) if b else a
result = -1
for i in range(s, e + 1):
	for j in range(i + 1, e + 1):
		if GCD(i, j) == 1:
			for k in range(j + 1, e + 1):
				if GCD(j, k) == 1 and GCD(i, k) != 1:
					print(i, j, k)
					result = 0
					break
		if not result:
			break
	if not result:
		break
if result:
	print(result)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l, r) = map(int, input().split())
b = []
c1 = 0
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for r in range(j + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, r) == 1 and (gcd(i, r) != 1):
				c1 = -1
				b.append([i, j, r])
				break
		if c1 == -1:
			break
	if c1 == -1:
		break
if c1 == -1:
	print(*b[0])
else:
	print('-1')


data = input().split()
(L, R) = (int(data[0]), int(data[1]))
if R == L + 1 or R == L:
	print('-1')
elif L % 2 == 0:
	print(L, L + 1, L + 2)
elif R - L + 1 > 3:
	print(L + 1, L + 2, L + 3)
else:
	print('-1')


(l, r) = list(map(int, input().split()))
if l % 2 is not 0:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print(l, l + 1, l + 2)


import sys, random

def gcd(x, y):
	if y == 0:
		return x
	else:
		return gcd(y, x % y)

def pollard(n):
	i = 1
	x = random.randint(0, n - 1)
	y = x
	k = 2
	while True:
		i = i + 1
		x = (x * x - 1) % n
		d = gcd(y - x, n)
		if d != 1 and d != n:
			print(d)
		if i == k:
			y = x
			k = 2 * k

def div(a, b):
	c = a + 2
	while not (gcd(c, a) != 1 and gcd(c, b) == 1):
		c += 1
	return c

def iff(l, r):
	if r - l <= 1:
		return -1
	a = l
	b = l + 1
	c = div(a, b)
	return (a, b, c)
(l, r) = map(int, input().split())
if l % 2 != 0:
	l += 1
if r - l <= 1:
	print(-1)
else:
	print(l, l + 1, l + 2)


n = input().split(' ')
a = int(n[0])
b = int(n[1])
output = [-1]
if a % 2 == 0:
	if a + 1 < b:
		output = [a, a + 1, a + 2]
elif a + 2 < b:
	output = [a + 1, a + 2, a + 3]
for element in output:
	print(element, end=' ')


from sys import exit
(l, r) = map(int, input().split())
if r - l <= 1:
	print('-1')
	exit(0)
else:
	if l % 2 != 0:
		l += 1
	if r - l <= 1:
		print(-1)
		exit(0)
	print(l, l + 1, l + 2)


import math
(a, b) = input().split(' ')
a = int(a)
b = int(b)
if b - a <= 2:
	if b - a == 2:
		if math.gcd(a, a + 1) == 1 and math.gcd(a + 1, b) == 1 and (math.gcd(a, b) != 1):
			print(a, a + 1, b)
			exit(0)
		else:
			print(-1)
	if b - a == 1:
		print(-1)
	if b - a == 0:
		print(-1)
else:
	i = a
	while i <= b:
		j = a + 1
		while j <= b:
			k = j + 1
			while k <= b:
				if math.gcd(i, j) == 1 and math.gcd(j, k) == 1 and (math.gcd(i, k) != 1):
					print(i, j, k)
					exit(0)
				k += 1
			j += 1
		i += 1
	print(-1)


inp = input().split(' ')
a = int(inp[0])
b = int(inp[1])
if b - a < 2:
	print(-1)
elif b - a == 2 and b % 2 == 1:
	print(-1)
else:
	if a % 2 == 1:
		a = a + 1
	print(a, a + 1, a + 2)


lr = input().split()
l = int(lr[0])
r = int(lr[1])
if r - l == 0 or r - l == 1 or (r - l == 2 and l % 2 == 1):
	print(-1)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
else:
	l += 1
	print(l, l + 1, l + 2)


def GCD(a, b):
	if b == 0:
		return a
	return GCD(b, a % b)
(l, r) = map(int, input().split())

def testing(l, r):
	for i in range(l, r + 1):
		a = i
		for m in range(a + 1, r + 1):
			if GCD(a, m) == 1:
				b = m
				for j in range(b + 1, r + 1):
					if GCD(j, b) == 1:
						if GCD(a, j) > 1:
							c = j
							return (a, b, c)
if True:
	m = [testing(l, r)]
	if m[0] == None:
		print(-1)
	else:
		for i in m[0]:
			print(i, end=' ')


(l, r) = [int(x) for x in input().split()]
arr = []

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
x = 0
for i in range(l, r - 1):
	if gcd(i, i + 1) == 1:
		if gcd(i, i + 2) > 1:
			print(i, i + 1, i + 2)
			x = 1
			break
if x == 0:
	print(-1)


from math import gcd
(l, r) = list(map(int, input().strip().split()))
if r - l < 2:
	print(-1)
else:
	flag7 = 1
	a1 = l
	a2 = l + 1
	a3 = l + 2
	while True:
		if a3 > r:
			a1 += 1
			a2 += 1
			a3 = a2 + 1
		if a1 > r or a2 > r or a3 > r:
			break
		if gcd(a1, a3) != 1 and gcd(a2, a3) == 1:
			flag7 = 0
			break
		a3 += 1
	if flag7 == 0:
		print(a1, a2, a3)
	else:
		print(-1)


from math import gcd
(a, b) = map(int, input().split())
found = False
for i in range(a, b + 1):
	if found:
		break
	for j in range(a + 1, b + 1):
		if found:
			break
		for k in range(a + 2, b + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				found = True
				(a, b, c) = (i, j, k)
				break
if found and a < b < c:
	print(a, b, c)
else:
	print(-1)


from math import gcd
from itertools import combinations
(l, r) = map(int, input().strip().split())
numbers = list(range(l, r + 1))
z = []
arr = list(combinations(numbers, 3))
for combination in arr:
	if gcd(combination[0], combination[1]) == 1 and gcd(combination[1], combination[2]) == 1 and (gcd(combination[0], combination[2]) != 1):
		z = [combination[0], combination[1], combination[2]]
		break
if len(z) > 0:
	print(*z, sep=' ')
else:
	print(-1)


import fractions
f = fractions.gcd
(l, r) = map(int, input().split())
for a in range(l, r + 1):
	for b in range(a, r + 1):
		for c in range(b, r + 1):
			if f(a, b) == 1 and f(b, c) == 1 and (f(a, c) != 1):
				print(a, b, c)
				exit()
print(-1)


x = [int(item) for item in input().split()]
if x[1] - x[0] <= 1:
	result = -1
elif x[0] % 2 != 0 and x[1] - x[0] <= 2:
	result = -1
elif x[0] % 2 == 0:
	result = f'{x[0]} {x[0] + 1} {x[0] + 2}'
else:
	result = f'{x[0] + 1} {x[0] + 2} {x[0] + 3}'
print(result)


(l, r) = list(map(int, input().split()))
if r - l <= 1:
	print(-1)
	exit()

def gcd_(a, b):
	if a == b:
		return a
	while b > 0:
		(a, b) = (min(a, b), max(a, b))
		b %= a
	return a
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			if gcd_(i, j) == 1 and gcd_(j, k) == 1 and (gcd_(i, k) > 1):
				print(i, j, k)
				exit()
print(-1)


def gcd(a, b):
	m = min(a, b)
	n = max(a, b)
	l = 0
	if a == 0 or b == 0:
		return 0
	else:
		for i in range(1000):
			l = n % m
			if l == 0:
				return m
			else:
				n = m
				m = l
				continue

def coprime(a, b):
	if gcd(a, b) == 1:
		return True
	else:
		return False
(a, b) = list((int(x) for x in input().split()))
k = -1
for i in range(a, b):
	for j in range(i, b):
		for k in range(j, b + 1):
			if coprime(i, j) == True and coprime(j, k) == True and (coprime(i, k) == False):
				print(i, j, k)
				exit()
print(-1)


from fractions import gcd
ranges = input().split(' ')
start = int(ranges[0])
end = int(ranges[1])
if end - start == 1:
	print(-1)
else:
	found = False
	for i in range(start + 1, end):
		if gcd(i - 1, i) == 1 and gcd(i, i + 1) == 1 and (gcd(i - 1, i + 1) != 1):
			found = True
			print(str(i - 1) + ' ' + str(i) + ' ' + str(i + 1))
			break
	if not found:
		print(-1)


from math import gcd
(a, b) = list(map(int, input().split()))
if a % 2 == 1:
	a += 1
if a + 2 > b:
	print(-1)
else:
	print(a, a + 1, a + 2)


def computeGCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
c = 0
(l, r) = list(map(int, input().split()))
if r - l == 1:
	print(-1)
else:
	for i in range(l, r + 1):
		for j in range(i + 1, r + 1):
			if computeGCD(i, j) == 1:
				for k in range(j + 1, r + 1):
					if computeGCD(j, k) == 1 and computeGCD(i, k) != 1:
						x = i
						y = j
						z = k
						c = 1
						break
			if c == 1:
				break
		if c == 1:
			break
	if c == 1:
		print(x, end=' ')
		print(y, end=' ')
		print(z)
	else:
		print(-1)


(l, r) = map(int, input().split())
if l % 2 != 0:
	l += 1
if r - l < 2:
	print('-1')
else:
	a = l
	b = l + 1
	c = l + 2
	print(a, b, c)


import math

class Solution:

	def __init__(self):
		(self.l, self.r) = map(int, input().strip().split())

	def solution(self):
		if self.l % 2:
			self.l += 1
		if self.l + 2 > self.r:
			print(-1)
		else:
			print(self.l, self.l + 1, self.l + 2)
ob = Solution()
ob.solution()


import math
(l, r) = map(int, input().split(' '))
c = 0
if r - l + 1 < 3:
	print(-1)
else:
	for i in range(l, r - 1):
		if c == 1:
			break
		for j in range(l + 1, r):
			if c == 1:
				break
			for k in range(j + 1, r + 1):
				if math.gcd(i, j) == 1 and math.gcd(j, k) == 1 and (math.gcd(i, k) != 1):
					print(i, j, k)
					c += 1
					break
	if c == 0:
		print(-1)


import math

class CodeforcesTask483ASolution:

	def __init__(self):
		self.result = ''
		self.l_r = []

	def read_input(self):
		self.l_r = [int(x) for x in input().split(' ')]

	def process_task(self):
		sol = False
		for a in range(self.l_r[0], self.l_r[1] + 1):
			for b in range(a + 1, self.l_r[1] + 1):
				for c in range(b + 1, self.l_r[1] + 1):
					if int(math.gcd(a, b)) == 1 and int(math.gcd(b, c)) == 1 and (int(math.gcd(a, c)) != 1):
						self.result = '{0} {1} {2}'.format(a, b, c)
						sol = True
		if not sol:
			self.result = '-1'

	def get_result(self):
		return self.result
Solution = CodeforcesTask483ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


def Gcd(x, y):
	while y:
		z = y
		y = x % y
		x = z
	return z

def solve(ll, rr):
	for i in range(ll, rr - 1):
		for j in range(i + 1, rr):
			for k in range(j + 1, rr + 1):
				if Gcd(i, j) == 1 and Gcd(j, k) == 1 and (Gcd(i, k) > 1):
					print(i, j, k)
					return 1
	return -1
s = input()
a = s.split()
l = int(a[0])
r = int(a[1])
ok = solve(l, r)
if ok == -1:
	print(-1)


import sys
(a, b) = map(int, input().split())
if b - a == 0:
	print('-1')
	sys.exit()
elif b - a == 1:
	print('-1')
	sys.exit()
elif b - a == 2:
	if a % 2 == 0:
		print(a, a + 1, a + 2)
	else:
		print('-1')
elif a % 2 == 0:
	print(a, a + 1, a + 2)
else:
	print(a + 1, a + 2, a + 3)


from math import gcd as bltin_gcd
(n, k) = map(int, input().split())
found = False
for i in range(n, k + 1):
	for j in range(n, k + 1):
		for z in range(n, k + 1):
			if bltin_gcd(i, j) == 1 and bltin_gcd(j, z) == 1 and (bltin_gcd(i, z) != 1):
				if i != j and i != z and (j != z) and (i < j) and (j < z) and (i < z):
					print(i, j, z)
					found = True
					break
		if found:
			break
	if found:
		break
if not found:
	print(-1)


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
(l, r) = map(int, input().split())
for i in range(l, r - 1):
	for j in range(i + 1, r):
		if gcd(i, j) == 1:
			for k in range(j + 1, r + 1):
				if gcd(j, k) == 1 and gcd(i, k) != 1:
					print(i, j, k)
					exit(0)
print(-1)


inp = list(map(int, input().split()))
l = inp[0]
r = inp[1]
if r - l + 1 == 3 and l % 2 == 1:
	print('-1')
elif r - l + 1 <= 2:
	print('-1')
elif l % 2 == 0:
	print(l, end=' ')
	print(l + 1, end=' ')
	print(l + 2)
else:
	k = l + 1
	print(k, end=' ')
	print(k + 1, end=' ')
	print(k + 2)


import sys
nums = sys.stdin.readline().split(' ')
l = int(nums[0])
r = int(nums[1])
if r - l < 2:
	print(-1)
	sys.exit()
if r - l == 2:
	if l % 2 == 1:
		print(-1)
		sys.exit()
	else:
		print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))
		sys.exit()
if l % 2 == 1:
	l = l + 1
print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))


def gcd(a, b):
	if a == 0:
		return b
	else:
		return gcd(b % a, a)
(a, b) = map(int, input().split())
c = True
for i in range(a, b + 1):
	for j in range(i + 1, b + 1):
		for k in range(j + 1, b + 1):
			l = gcd(i, j)
			m = gcd(j, k)
			n = gcd(i, k)
			if l == 1 and m == 1 and (n != 1):
				print(i, j, k)
				c = False
			if not c:
				break
		if not c:
			break
	if not c:
		break
if c:
	print(-1)


def f(ll):
	(l, r) = ll
	if r - l < 2 or (r - l == 2 and l % 2 > 0):
		return [-1]
	return [l, l + 1, l + 2] if l % 2 == 0 else [l + 1, l + 2, l + 3]
l = list(map(int, input().split()))
print(*f(l))


readints = lambda : map(int, input().split(' '))
(l, r) = readints()
if r - l + 1 < 3:
	print(-1)
elif r - l + 1 == 3:
	if l % 2 == 0:
		print(l, l + 1, r)
	else:
		print(-1)
else:
	for i in range(l, r + 1):
		if i % 2 == 0:
			print(i, i + 1, i + 2)
			break


(x, y) = map(int, input().split())
if y - x < 2:
	print(-1)
elif y - x == 2 and x % 2 == 1:
	print(-1)
elif x % 2 == 1:
	print(x + 1, x + 2, x + 3)
else:
	print(x, x + 1, x + 2)


(n, m) = map(int, input().split())
if n % 2 == 0:
	a = n
else:
	a = n + 1
b = a + 1
c = b + 1
if (c > m) | (m - n <= 1):
	print('-1')
else:
	print(a, b, c)


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

def ri():
	return int(input())

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

def ia_to_s(a):
	return ' '.join([str(s) for s in a])

def solve(l, r):
	if r - l < 2:
		return [-1]
	if r - l == 2:
		if l % 2 == 0:
			return [l, l + 1, l + 2]
		else:
			return [-1]
	if l % 2 == 1:
		l += 1
	return [l, l + 1, l + 2]

def main():
	(l, r) = ria()
	print(ia_to_s(solve(l, r)))
main()


import math
(l, r) = [int(p) for p in input().split()]
for i in range(l, r + 1):
	a = i
	b = i + 1
	for j in range(i + 2, r + 1):
		if math.gcd(a, j) > 1 and math.gcd(b, j) == 1:
			print(a, b, j)
			exit()
print(-1)


import sys

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

def sp():
	return map(int, data().split())

def l():
	return list(sp())
bounds = l()
l = bounds[0]
r = bounds[1]
if r - l + 1 < 3:
	print(-1)
	exit()
elif l % 2 == 0:
	print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))
elif r - l + 1 > 3:
	print(str(l + 1) + ' ' + str(l + 2) + ' ' + str(l + 3))
else:
	print(-1)


(a, m) = map(int, input().split())
if m < a + 2:
	print(-1)
elif a % 2 == 0:
	print(a, a + 1, a + 2)
elif m < a + 3:
	print(-1)
else:
	print(a + 1, a + 2, a + 3)


from fractions import gcd
(left, right) = tuple(map(int, input().split()))
right += 1
for a in range(left, right):
	for b in range(a + 1, right):
		for c in range(b + 1, right):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				print(a, b, c)
				exit()
print(-1)


(l, r) = map(int, input().split())
a = -1
b = -1
c = -1
i = l
while i <= r:
	if i % 2 == 0:
		a = i
		break
	i += 1
while i <= r:
	if i % 2 != 0:
		b = i
		break
	i += 1
while i <= r:
	if i % 2 == 0:
		c = i
		break
	i += 1
if a == -1 or b == -1 or c == -1:
	print(-1)
else:
	print(a, b, c)


from math import gcd
(l, r) = map(int, input().split())
s = []
for i in range(l, r):
	for j in range(l + 1, r + 1):
		if gcd(i, j) == 1:
			s.append([i, j])
for i in range(0, len(s) - 1):
	for j in range(i + 1, len(s)):
		if s[i][1] == s[j][0] and s[i][0] != s[j][1]:
			if gcd(s[i][0], s[j][1]) != 1:
				print(s[i][0], s[i][1], s[j][1])
				exit()
else:
	print(-1)


(a, b) = map(int, input().split())
if a % 2 != 0:
	a += 1
if a + 2 > b:
	print(-1)
	exit()
print(a, a + 1, a + 2)


(l, r) = input().split(' ')
l = int(l)
r = int(r)

def gcd(x, y):
	while y != 0:
		(x, y) = (y, x % y)
	return int(x)

def main():
	global l
	global r
	a = l
	b = a + 1
	c = r
	if l + 1 >= r:
		print(-1)
		return
	while 1:
		if gcd(a, c) - 1 != 0 and gcd(b, c) - 1 == 0 and (a != b and b != c and (a != c)):
			print('%d %d %d ' % (a, b, c))
			return
		a = a + 1
		b = a + 1
		if b >= c:
			a = l
			b = a + 1
			r = r - 1
			c = r
		if l >= r:
			print(-1)
			return
main()


(n, d) = input().split()
n = int(n)
d = int(d)
if d - n < 2:
	print(-1)
elif n % 2 == 0:
	print(n, n + 1, n + 2)
elif d - n > 2:
	print(n + 1, n + 1 + 1, n + 1 + 2)
else:
	print(-1)


def gcd(a, b):
	if a == 0 or b == 0:
		return a + b
	else:
		return gcd(b, a % b)
(l, r) = list(map(int, input().split()))
r = r + 1
for a in range(l, r):
	for b in range(a + 1, r):
		for c in range(b + 1, r):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				print(str(a) + ' ' + str(b) + ' ' + str(c))
				return
print(-1)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r) = map(int, input().split())
found = False
for a in range(l, r - 1):
	for b in range(a + 1, r):
		if gcd(a, b) == 1:
			for c in range(b + 1, r + 1):
				if gcd(b, c) == 1 and gcd(a, c) != 1:
					found = True
					break
		if found:
			break
	if found:
		break
if found:
	print(a, b, c)
else:
	print(-1)


import sys, math, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
(a, b) = M()
if b - a <= 1:
	print(-1)
elif b - a == 2 and a % 2 == 1:
	print(-1)
elif a % 2 == 0:
	print(a, a + 1, a + 2)
else:
	print(a + 1, a + 2, a + 3)


import math
inp = input().split()
l = int(inp[0])
r = int(inp[1])
i = l
while i < r - 1:
	j = i + 1
	while j < r:
		if math.gcd(i, j) == 1:
			k = j + 1
			while k <= r:
				if math.gcd(j, k) == 1 and math.gcd(i, k) != 1:
					print(i, ' ', j, ' ', k)
					exit(0)
				k += 1
		j += 1
	i += 1
print(-1)


from sys import exit

def gcd(a, b):
	return gcd(b, a % b) if b else a
(l, r) = map(int, input().split())
for i in range(l, r + 1):
	for j in range(i + 1, r + 1):
		for k in range(j + 1, r + 1):
			ij = gcd(i, j)
			jk = gcd(j, k)
			ik = gcd(i, k)
			if ij == jk and jk == 1 and (ik != 1):
				print(i, j, k)
				exit(0)
print(-1)


def main():
	(n, m) = map(int, input().split())
	if n % 2 == 1:
		n += 1
	if m - n < 2:
		print(-1)
	else:
		print(n, n + 1, n + 2)
main()


(l, m) = map(int, input().split())
if l % 2:
	l = l + 1
if l + 2 > m:
	print('-1')
else:
	print(l, l + 1, l + 2)


import math
(l, r) = list(map(int, input().split()))

def coprime(x, y):
	while x < r - 1:
		for i in range(x + 2, y + 1):
			if math.gcd(x, i) > 1 and math.gcd(x + 1, i) == 1:
				return (x, x + 1, i)
		x += 1
	return -1
if r - l < 2:
	print(-1)
else:
	ans = coprime(l, r)
	if ans == -1:
		print(-1)
	else:
		print(*ans)


from fractions import gcd
(l, r) = map(int, input().strip().split())
found = False
for i in range(l, r - 1):
	if i % 2 == 0:
		if gcd(i, i + 1) == 1:
			print(i, i + 1, i + 2)
			found = True
			break
if not found:
	print(-1)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
x = list(map(int, input().split()))
l = x[0]
r = x[1]
i = 0
a = l
b = 0
y = False
c = 0
for k in range(l, r):
	a = k
	for i in range(k + 1, r):
		if gcd(k, i):
			b = i
			break
	if b == 0:
		break
	for j in range(i, r + 1):
		if gcd(b, j) == 1 and gcd(a, j) != 1:
			y = True
			c = j
			break
	if y:
		break
if y:
	print(a, b, c)
else:
	print('-1')


(l, r) = map(int, input().split())
a = l
while not a % 2 == 0:
	a += 1
b = a + 1
c = a + 2
if a >= l and c <= r:
	print(a, b, c)
else:
	print(-1)


import math
(l, r) = map(int, input().split())
if r - l <= 1:
	print(-1)
	exit()
for a in range(l, r - 1):
	for b in range(a, r):
		for c in range(b, r + 1):
			gcd_ab = math.gcd(a, b)
			gcd_bc = math.gcd(b, c)
			gcd_ac = math.gcd(a, c)
			if gcd_ab == 1 and gcd_bc == 1 and (gcd_ac != 1):
				print('{} {} {}'.format(a, b, c))
				exit()
print(-1)


(l, r) = map(int, input().split())
if r - l >= 1:
	for i in range(l, r + 1):
		if i % 2 != 0:
			i += 1
		elif i + 2 > r:
			print(-1)
			exit()
		else:
			print(i, i + 1, i + 2)
			exit()
else:
	print(-1)


import sys
import math

def nod(a, b):
	if b == 0:
		return a
	r = a % b
	return nod(b, r)
(l, r) = [int(x) for x in sys.stdin.readline().split()]
res = []
for j in range(l, r):
	for i in range(j + 1, r + 1):
		if nod(i, j) != 1 and nod(j, j + 1) == 1 and (nod(j + 1, i) == 1):
			res.append(str(j))
			res.append(str(j + 1))
			res.append(str(i))
			print(' '.join(res))
			exit()
print(-1)


__author__ = 'zabidon'
(l, r) = map(int, input().split())

def alg_evk(a, b):
	while a % b:
		(b, a) = (a % b, b)
	return b
found = False
for a in range(r + 1)[l:]:
	if found:
		break
	for b in range(r + 1)[l:]:
		if found:
			break
		if alg_evk(a, b) != 1:
			continue
		for c in range(r + 1)[l:]:
			if a < b < c:
				if alg_evk(b, c) == 1 and alg_evk(a, c) != 1:
					found = True
					result = (a, b, c)
					break
if found:
	print('{} {} {}'.format(result[0], result[1], result[2]))
else:
	print(-1)


(x, y) = [int(i) for i in input().split()]
if y - (x + x % 2) > 1:
	print(x + x % 2, x + x % 2 + 1, x + x % 2 + 2)
else:
	print(-1)


p = input().split()
l = int(p[0])
r = int(p[1])
if r - l < 2:
	print(-1)
elif l % 2 == 0:
	print(l, l + 1, l + 2)
elif r - l == 2:
	print(-1)
else:
	print(l + 1, l + 2, l + 3)


(left, r) = input().split(' ')
left = int(left)
r = int(r)
if left % 2 != 0:
	left += 1
if left + 2 > r:
	print(-1)
else:
	print(left, left + 1, left + 2)


from sys import stdin, stdout
lr = list(map(int, stdin.readline().split()))
l = lr[0]
r = lr[1]
if r - l < 2:
	stdout.write('-1')
elif l % 2 == 0:
	stdout.write(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))
elif r - l < 3:
	stdout.write('-1')
else:
	stdout.write(str(l + 1) + ' ' + str(l + 2) + ' ' + str(l + 3))


(l, r) = map(int, input().split())
(a, b, c) = (0, 0, 0)
if abs(l - r) < 3 and l % 2 == 1 or (r % 2 == 1 and abs(l - r) < 3) or l == r:
	print(-1)
elif l % 2 == 0:
	a = l
	b = +l + 1
	c = l + 2
	print(a, b, c)
elif l % 2 == 1:
	a = l + 1
	b = l + 2
	c = l + 3
	print(a, b, c)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l_val, r_val) = list(map(int, input().split()))
for a_val in range(l_val, r_val + 1):
	for b_val in range(a_val + 1, r_val + 1):
		for c_val in range(b_val + 1, r_val + 1):
			if gcd(a_val, b_val) == 1:
				if gcd(b_val, c_val) == 1:
					if gcd(a_val, c_val) != 1:
						print(a_val, b_val, c_val)
						exit(0)
					else:
						continue
				else:
					continue
			else:
				continue
print('-1')


import math, sys
from collections import Counter, defaultdict, deque
from sys import stdin, stdout
input = stdin.readline
li = lambda : list(map(int, input().split()))

def case():
	(l, r) = li()
	if r - l <= 1 and l % 2 == 0:
		print(-1)
	elif r - l <= 2 and l % 2 != 0:
		print(-1)
	elif l % 2 == 0:
		print(l, l + 1, l + 2)
	else:
		l += 1
		print(l, l + 1, l + 2)
for _ in range(1):
	case()


n = input().split()
(l, r) = (int(n[0]), int(n[1]))
if l % 2 == 1:
	l += 1
if l + 2 > r:
	print(str(-1))
else:
	print(str(l) + ' ' + str(l + 1) + ' ' + str(l + 2))


a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
l = a[0]
r = a[1]
if r - l < 2:
	print(-1)
elif r - l == 2 and r % 2:
	print(-1)
elif l % 2:
	print(l + 1, l + 2, l + 3)
else:
	print(l, l + 1, l + 2)


import math as m

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

def mmap():
	return map(int, input().split())
(l, r) = mmap()
if l % 2 != 0:
	l += 1
if r - l + 1 >= 3:
	print(l, l + 1, l + 2)
else:
	print(-1)


(n, k) = map(int, input().split())
if k - n >= 3:
	if n % 2 == 0:
		print(n, n + 1, n + 2)
	else:
		print(n + 1, n + 2, n + 3)
elif k - n <= 1:
	print(-1)
elif n % 2 == 0:
	print(n, n + 1, n + 2)
else:
	print(-1)


def main():
	(l, r) = map(int, input().strip().split())
	cache = {}
	for a in range(l, r - 1):
		for c in range(a + 2, r + 1, 2):
			if a & 1:
				(p, q) = (a, c)
				while p:
					(q, p) = (p, q % p)
				if q == 1:
					continue
			for b in range(a + 1, c, 2):
				if (b, c) not in cache:
					(p, q) = (b, c)
					while p:
						(q, p) = (p, q % p)
					if q == 1:
						cache[b, c] = True
					else:
						cache[b, c] = False
						continue
				if (a, b) not in cache:
					(p, q) = (a, b)
					while p:
						(q, p) = (p, q % p)
					cache[a, b] = q == 1
				if cache[a, b] and cache[b, c]:
					return (a, b, c)
	return (-1,)
print(*main())


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

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

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

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=2):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	new_number = 0
	while number > 0:
		new_number += number % base
		number //= base
	return new_number

def cdiv(n, k):
	return n // k + (n % k != 0)

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True
(l, r) = (int(x) for x in input().split())
l += l % 2
if r - l < 2:
	print(-1)
else:
	print(l, l + 1, l + 2)


def gccd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a == 1

def main():
	(l, r) = map(int, input().split())
	if r - l < 2:
		print('-1')
		return ()
	else:
		m = False
		a = b = c = 0
		for i in range(l, r - 1):
			for j in range(i + 1, r):
				for k in range(j + 1, r + 1):
					if gccd(i, j) and gccd(j, k):
						if gccd(i, k):
							continue
						else:
							(a, b, c) = (i, j, k)
							m = True
							break
				if m:
					break
			if m:
				break
	if m:
		print(a, b, c)
	else:
		print(-1)
main()


(n, k) = map(int, input().split())
if n % 2 != 0:
	n += 1
if n + 2 > k:
	print('-1')
else:
	print(str(n) + ' ' + str(n + 1) + ' ' + str(n + 2))


from math import gcd
from itertools import combinations
(a, b) = map(int, input().split())

def isCoPrime(x, y):
	if gcd(x, y) == 1:
		return True

def isGood(x, y, z):
	if isCoPrime(x, y) and isCoPrime(y, z) and (not isCoPrime(x, z)):
		return True
perm = list(combinations(list(range(a, b + 1)), 2))
if abs(a - b) <= 1:
	print(-1)
	quit()
for j in perm:
	f = j[0]
	l = j[1]
	if abs(j[1] - j[0]) == 1:
		continue
	for i in range(f + 1, l):
		if isGood(f, i, l):
			print(f, i, l)
			quit()
print(-1)


(l, r) = map(int, input().split())

def euclid(n, m):
	if n % m == 0:
		return m
	else:
		return euclid(m, n % m)
if r - l + 1 < 3:
	print(-1)
else:
	y = False
	a = 0
	b = 0
	c = 0
	for i in range(l, r - 1):
		for j in range(i + 1, r):
			if euclid(i, j) != 1:
				continue
			for k in range(j + 1, r + 1):
				if euclid(j, k) != 1:
					continue
				if euclid(i, k) > 1:
					a = i
					b = j
					c = k
					y = True
					break
			if y:
				break
		if y:
			break
	if not y:
		print(-1)
	else:
		print(a, b, c)


import sys
(l, r) = map(lambda a: int(a), sys.stdin.readline().split(' '))
if r - l < 2:
	print(-1)
	exit()
if l % 2 == 0:
	print(l, ' ', l + 1, ' ', l + 2)
	exit()
if r - l > 2:
	print(l + 1, ' ', l + 2, ' ', l + 3)
	exit()
print(-1)


import math
(l, r) = map(int, input().split())
if l % 2 == 1:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print(l, l + 1, l + 2)


import math

def checkcoprime(a, b):
	for i in range(2, min(a, b) + 1):
		if a % i == 0 and b % i == 0:
			return False
	return True

def coprime(s, r):
	for j in range(s, r + 1):
		for k in range(j + 1, r + 1):
			for l in range(k + 1, r + 1):
				if math.gcd(j, k) == 1 and math.gcd(k, l) == 1 and (math.gcd(j, l) != 1):
					print(j, k, l)
					return
	print(-1)
	return
(s, r) = map(int, input().split())
coprime(s, r)


from sys import stdin
__author__ = 'artyom'

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)
(l, r) = list(map(int, stdin.readline().strip().split()))
for a in range(l, r - 1):
	for b in range(a + 1, r):
		if gcd(a, b) == 1:
			for c in range(b + 1, r + 1):
				if gcd(b, c) == 1 and gcd(a, c) > 1:
					print(' '.join(map(str, [a, b, c])))
					exit()
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')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

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

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if not True else 1):
	(x, y) = map(int, input().split())
	if x == y or x + 1 == y:
		print(-1)
		continue
	if x % 2 != 0:
		x += 1
	if y >= x + 2:
		print(x, x + 1, x + 2)
		continue
	print(-1)


(l, r) = list(map(int, input().split()))

def coprime(x, y):
	while y != 0:
		(x, y) = (y, x % y)
	return x == 1

def sol(l, r):
	(a, b, res, c) = (0, 0, 0, 0)
	for k in range(l, r):
		for j in range(k + 1, r + 1):
			for i in range(k, j + 1):
				if coprime(k, i) and coprime(i, j) and (coprime(k, j) != True):
					res = 1
					a = i
					b = j
					c = k
					break
			if res:
				break
		if res:
			break
	if res:
		print(c, a, b)
	else:
		print('-1')
if r - l <= 1:
	sol(r, l)
else:
	sol(l, r)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r) = map(int, input().split())
if r - l == 0 or r - l == 1:
	print(-1)
elif r - l == 2:
	if l % 2 == 0:
		print(l, l + 1, r)
	else:
		print(-1)
elif r - l > 2:
	if l % 2 == 0:
		print(l, l + 1, l + 2)
	else:
		l += 1
		print(l, l + 1, l + 2)


import copy

def MCD(a, b):
	while b > 0:
		aux = a % b
		a = b
		b = aux
	return a
(a, b) = [int(i) for i in input().split()]
ap = copy.copy(a)
bp = copy.copy(b)
if b - a <= 1:
	print(-1)
else:
	brk = False
	counter = False
	while not counter:
		for i in range(1, b - a):
			j = a + i
			if (MCD(a, j) == 1 and MCD(j, b) == 1) and MCD(a, b) != 1:
				print(a, j, b)
				counter = True
				break
			while not counter:
				for k in range(1, b - a):
					l = a + k
					if (MCD(a, l) == 1 and MCD(l, b) == 1) and MCD(a, b) != 1:
						print(a, l, b)
						counter = True
						break
				b -= 1
				if b < a:
					break
			if counter:
				break
			b = copy.copy(bp)
		a += 1
		if b < a:
			break
	if counter == False:
		print(-1)


(r, l) = map(int, input().split())
num_range = l - r + 1
if num_range < 3:
	print(-1)
elif num_range > 3:
	print(r + r % 2, r + 1 + r % 2, r + 2 + r % 2)
elif r % 2:
	print(-1)
else:
	print(r, r + 1, r + 2)


def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(a, b) = map(int, input().split())
(s1, s2, s3) = (0, 0, 0)
if b - a < 2:
	print(-1)
	exit()
else:
	for i in range(a, b):
		for j in range(i + 1, b + 1):
			if gcd(i, j) == 1:
				(s1, s2) = (i, j)
				for k in range(s2 + 1, b + 1):
					if gcd(s1, k) != 1 and gcd(s2, k) == 1:
						s3 = k
						print(s1, s2, s3)
						exit()
	print(-1)


import math

def input1(string):
	while 1:
		try:
			return int(input('\t' + string))
		except Exception:
			continue
(x, y) = list(map(int, input().split()))
if x % 2 != 0:
	x = x + 1
if x + 2 > y:
	print(-1)
	exit()
print(x.__str__() + ' ' + (x + 1).__str__() + ' ' + (x + 2).__str__())


from math import gcd
(ll, r) = map(int, input().split())
f = 0
while ll < r:
	for i in range(ll + 2, r + 1):
		if gcd(ll, i) > 1 and gcd(ll + 1, i) == 1:
			f = i
			break
	if f:
		break
	ll += 1
if f:
	print(ll, ll + 1, f)
else:
	print(-1)


(m, n) = [int(x) for x in input().split()]
if n - m <= 1:
	print(-1)
elif n - m == 2:
	if m % 2 == 0:
		print(m, m + 1, n)
	else:
		print('-1')
elif m % 2 == 0:
	print(m, m + 1, m + 2)
else:
	print(m + 1, m + 2, m + 3)


(l, r) = [int(i) for i in input('').split(' ')]
if l + 1 == r:
	print('-1')
else:
	from fractions import gcd
	gcd_ = int()
	for i in range(l, r - 1):
		gcd_ = (gcd(i, i + 1) == 1) * 4 + (gcd(i + 1, i + 2) == 1) * 2 + (gcd(i + 2, i) == 1) * 1
		if gcd_ in [3, 5, 6]:
			print(i, i + 1, i + 2)
			exit(0)
	print('-1')


def hypothesis(l, r):
	if l % 2 != 0:
		l += 1
	if l + 2 > r:
		return [-1]
	return (l, l + 1, l + 2)
(L, R) = [int(i) for i in input().split()]
print(*hypothesis(L, R))


(li, ri) = list(map(int, input().split()))
if li % 2 != 0:
	li += 1
if li + 2 > ri:
	print(-1)
else:
	print(li, li + 1, li + 2)


import sys
input = sys.stdin.readline
(x, y) = map(int, input().split())
if y - x < 2:
	print(-1)
elif x % 2 != 0 and y - x == 2:
	print(-1)
elif x % 2 == 0:
	print(x, x + 1, x + 2)
else:
	print(x + 1, x + 2, x + 3)


tmp = list(map(int, input().split()))
start = tmp[0]
end = tmp[1]
if start % 2 != 0:
	start += 1
if end - start < 2:
	print(-1)
else:
	print(str(start) + ' ' + str(start + 1) + ' ' + str(start + 2))


def main():
	(l, r) = list(map(int, input().split()))
	if r - l + 1 < 3:
		print(-1)
	elif l % 2 != 0 and r - l + 1 <= 3:
		print(-1)
	elif l % 2 != 0:
		print(l + 1, l + 2, l + 3)
	else:
		print(l, l + 1, l + 2)
t = 1
while t != 0:
	main()
	t -= 1


import time
import math
s = []

def sieve(limit):
	a = [True] * limit
	a[0] = a[1] = False
	ans = []
	for (i, isprime) in enumerate(a):
		if isprime:
			ans.append(i)
			for n in range(i * i, limit, i):
				a[n] = False
	return ans

def coprime(a, b):
	global s
	k = int(math.sqrt(a))
	if b - a == 1:
		return True
	s = sieve(50)
	for i in s:
		if a % i == 0 and b % i == 0:
			return False
	return True

def test(a, z):
	global s
	b = a + 1
	c = b + 1
	if z - a < 2:
		return [-1]
	if z - a == 2 and a % 2 == 1:
		return [-1]
	if a % 2 == 0:
		return [a, b, c]
	else:
		while c <= z:
			if coprime(b, c) and (not coprime(a, c)):
				return [a, b, c]
			c += 2
	return [a + 1, a + 2, a + 3]
info = list(map(int, input().split()))
ans = test(info[0], info[1])
if ans == [-1]:
	print(-1)
else:
	for i in ans:
		print(i, end=' ')


import math

def main():
	(l, r) = map(int, input().split())
	for c in range(l, r + 1):
		for b in range(l, c):
			for a in range(l, b):
				if math.gcd(a, b) == 1 and math.gcd(b, c) == 1 and (math.gcd(a, c) > 1):
					print(a, b, c)
					return
	print(-1)
main()


(l, r) = input().split(' ')
l = int(l)
r = int(r)
i = l
c = 0
while i + 2 <= r:
	if i % 2 == 0:
		print(i, i + 1, i + 2)
		c = 1
		break
	else:
		i += 1
if c == 0:
	print('-1')


from math import gcd

def main():
	(L, R) = map(int, input().split())
	flag = False
	nonCoPrimeList = []
	for i in range(L, R):
		for j in range(i + 1, R + 1):
			if gcd(i, j) != 1:
				nonCoPrimeList.append((i, j))
	for pair in nonCoPrimeList:
		for j in range(pair[0] + 1, pair[1]):
			if gcd(pair[0], j) == 1 and gcd(j, pair[1]) == 1:
				ans = sorted([pair[0], j, pair[1]])
				flag = True
				break
		if flag:
			break
	if flag:
		print(*ans)
	else:
		print(-1)
main()


def gcd(a, b):
	while b != 0:
		t = b
		b = a % b
		a = t
	return a
(l, r) = map(int, input().split())
a = l
b = 0
c = r
firstCondition = False
secondCondition = False
while a < c:
	firstCondition = False
	t = a
	while t < c:
		if gcd(t, c) != 1:
			firstCondition = True
			a = t
			break
		else:
			t += 1
	b = a + 1
	while b < c and firstCondition:
		if gcd(a, b) == 1 and gcd(b, c) == 1:
			secondCondition = True
			break
		else:
			b += 1
	if firstCondition and secondCondition:
		break
	c -= 1
if firstCondition and secondCondition:
	print(a, b, c)
else:
	print(-1)


(b, a) = [int(i) for i in input().split()]
if a - b < 2:
	print(-1)
elif a - b == 2:
	if b % 2 == 0:
		print(b, b + 1, b + 2)
	else:
		print(-1)
elif b % 2 == 0:
	print(b, b + 1, b + 2)
else:
	print(b + 1, b + 2, b + 3)


from math import gcd

def counter_example(l, r):
	for a in range(l, r + 1):
		for b in range(a + 1, r + 1):
			for c in range(b + 1, r + 1):
				if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
					return (a, b, c)
	return (-1, -1, -1)
(l, r) = map(int, input().split())
(a, b, c) = counter_example(l, r)
if a == -1:
	print(-1)
else:
	print(a, b, c)


(l, r) = list(map(int, input().split()))
f = 0

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
for a in range(l, r + 1):
	for b in range(a + 1, r + 1):
		for c in range(b + 1, r + 1):
			if gcd(a, b) == 1 and gcd(b, c) == 1 and (gcd(a, c) != 1):
				print(a, b, c)
				f = 1
				break
		if f == 1:
			break
	if f == 1:
		break
else:
	print(-1)


(l, r) = [int(y) for y in input().split()]
if r % 2 != 0:
	r -= 1
if r - 2 <= 1 or r - 2 < l:
	print(-1)
else:
	print(r - 2, r - 1, r)


from math import gcd
(l, r) = (int(i) for i in input().split())
(a, b, c) = (0, 0, 0)
for a in range(l, r - 1):
	for c in range(a, r + 1):
		if gcd(a, c) == 1:
			continue
		else:
			for b in range(a + 1, c):
				if gcd(a, b) == 1 and gcd(b, c) == 1:
					print(a, b, c)
					quit()
print(-1)


from sys import stdin, stdout
from collections import deque
st = lambda : list(stdin.readline().strip())
li = lambda : list(map(int, stdin.readline().split()))
mp = lambda : map(int, stdin.readline().split())
inp = lambda : int(stdin.readline())
pr = lambda n: stdout.write(str(n) + '\n')
from random import randint
mod = 1000000007

def solve():
	(l, r) = mp()
	if r - l < 2:
		pr(-1)
	elif l % 2 == 0:
		print(l, l + 1, l + 2)
	elif r - l - 1 >= 2:
		print(l + 1, l + 2, l + 3)
	else:
		pr(-1)
for _ in range(1):
	solve()


import sys
import math
from sys import stdin, stdout

def sieve(N):
	primeNumbers = [True] * (N + 1)
	primeNumbers[0] = False
	primeNumbers[1] = False
	i = 2
	while i * i <= N:
		j = i
		if primeNumbers[j]:
			while j * i <= N:
				primeNumbers[j * i] = False
				j += 1
		i += 1
	return primeNumbers

def getPrime(N):
	primes = sieve(N)
	result = []
	for i in range(len(primes)):
		if primes[i]:
			result.append(i)
	return result

def factor(N):
	factors = []
	i = 1
	while i * i <= N:
		if N % i == 0:
			factors.append(i)
			if i != N // i:
				factors.append(N // i)
		i += 1
	return sorted(factors)

def reduceB(b):
	mod = 0
	for i in range(0, len(b)):
		mod = (mod * 10 + ord(b[i])) % 1000000007
	return mod

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

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():
	(l, r) = get_ints_in_variables()
	if r - l + 1 < 3:
		print(-1)
		return
	if l % 2 == 0:
		print(l, l + 1, l + 2)
		return
	if r - l + 1 > 3:
		print(l + 1, l + 2, l + 3)
		return
	print(-1)
main()


import sys
inf = float('inf')
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

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

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

def input():
	return sys.stdin.readline().strip()
(l, r) = get_ints()
flag = 0
for i in range(l, r - 1):
	for j in range(i + 1, r):
		for k in range(j + 1, r + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				flag = 1
				(store1, store2, store3) = (i, j, k)
				break
		if flag == 1:
			break
	if flag == 1:
		break
if flag == 1:
	print(store1, store2, store3)
else:
	print(-1)


import math
(l, r) = [int(i) for i in input().split()]
complit = False
for a in range(l, r - 1):
	for b in range(a + 1, r):
		for c in range(b + 1, r + 1):
			if math.gcd(a, b) == 1 and math.gcd(b, c) == 1 and (math.gcd(a, c) != 1):
				print(a, b, c)
				complit = True
				break
		if complit:
			break
	if complit:
		break
else:
	print(-1)


import math

def func():
	(l, r) = [int(x) for x in input().split()]
	(a, b, c) = (0, 0, 0)
	for i in range(l, r - 1):
		for j in range(i + 1, r):
			for k in range(j + 1, r + 1):
				if math.gcd(i, j) == 1 and math.gcd(j, k) == 1 and (math.gcd(i, k) != 1):
					print(i, j, k)
					found = True
					return 0
	return 1
if func() != 0:
	print(-1)


def main():
	(L, R) = [int(c) for c in input().split()]
	if R - L + 1 == 3 and L % 2 != 0 or R - L + 1 < 3 or (L == 1 and R == 3):
		print(-1)
	elif R % 2 == 0:
		print(R - 2, R - 1, R)
	else:
		print(R - 3, R - 2, R - 1)
main()


(left, right) = map(int, input().split())
if left % 2:
	left += 1
if left + 2 > right:
	print(-1)
else:
	print(left, left + 1, left + 2)


def gcd(a, b):
	for x in range(3, a, 2):
		if a % x == 0 and b % x == 0:
			return x
	return 1

def counterexample(l, r):
	if r - l <= 1:
		return -1
	elif r - l == 2:
		if l % 2 == 0:
			return str(l) + ' ' + str(l + 1) + ' ' + str(r)
		elif gcd(l % 10, r % 10) != 1:
			return str(l) + ' ' + str(l + 1) + ' ' + str(r)
		else:
			return -1
	elif l % 2 == 0:
		return str(l) + ' ' + str(l + 1) + ' ' + str(l + 2)
	else:
		return str(l + 1) + ' ' + str(l + 2) + ' ' + str(l + 3)
(a, b) = list(map(int, input().split()))
print(counterexample(a, b))


x = input()
(l, r) = list(map(int, x.strip().split()))

def gcd(a, b):
	if a < b:
		return gcd(b, a)
	if a % b == 0:
		return b
	else:
		return gcd(b, a % b)
try:
	for a in range(l, r + 1):
		for b in range(a + 1, r + 1):
			for c in range(b + 1, r + 1):
				if gcd(a, b) == gcd(b, c) != gcd(a, c):
					print(a, b, c)
					1 / 0
	print(-1)
except:
	pass


(L, R) = [int(x) for x in input().split()]
if R - L + 1 < 3:
	print(-1)
	exit()
if L % 2 == 0:
	print(L, L + 1, L + 2)
	exit()
if R - L + 1 > 3:
	print(L + 1, L + 2, L + 3)
	exit()
print(-1)


def hcf(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(x, y) = [int(x) for x in input('').split()]
if y - x <= 1:
	print(-1)
elif y - x == 2:
	if x % 2 == 0:
		print(x, x + 1, y)
	else:
		print(-1)
elif x % 2 == 0:
	print(x, x + 1, x + 2)
else:
	for x in range(x, y):
		i = x + 2
		while i <= y:
			if hcf(i, x) > 1 and hcf(i, x + 1) < 2:
				print(x, x + 1, i)
				exit()
			i = i + 1
	print(-1)


def gcd(a, b):
	while a:
		(a, b) = (b % a, a)
	return b
(a, b) = [int(x) for x in input().split()]
for i in range(a, b + 1):
	for j in range(i + 1, b + 1):
		for k in range(j + 1, b + 1):
			if gcd(i, j) == 1 and gcd(j, k) == 1 and (gcd(i, k) != 1):
				print(i, j, k)
				exit(0)
print(-1)


from math import gcd
(l, r) = map(int, input().split())
x = l
while x + 2 <= r and gcd(x, x + 2) == 1:
	x += 1
if x + 2 <= r:
	print(x, x + 1, x + 2)
else:
	print(-1)


(a, b) = map(int, input().strip().split(' '))
l = []
for i in range(a, b + 1):
	l.append(i)

def ans():
	if l[-1] - l[0] < 2:
		return -1
	else:
		for i in range(len(l)):
			for j in range(2, 1000):
				if l[i] % j == 0:
					for k in range(i + 1, len(l)):
						if l[k] % j == 0:
							count = 0
							for m in range(1, 1000):
								if l[i + 1] % m == 0 and l[k] % m == 0:
									count += 1
							if count == 1:
								c = 0
								for m in range(1, 1000):
									if l[i] % m == 0 and l[k] % m == 0:
										c += 1
								if c > 1:
									return [l[i], l[i + 1], l[k]]
	return -1
if ans() == -1:
	print(-1)
else:
	for i in ans():
		print(i, end=' ')


(l, r) = map(int, input().split())
c = -1
if l == r or r - l == 1:
	print(-1)
	c = 1
if l % 2 == 0 and c != 1:
	print(l, l + 1, l + 2)
	c = 1
if l % 2 != 0 and c != 1 and (r - l > 2):
	print(l + 1, l + 2, l + 3)
	c = 1
if c != 1:
	print(c)


n = list(map(int, input().split()))
l = n[0]
r = n[1]

def run():
	if r - l + 1 < 3:
		print(-1)
		return 0
	if l % 2 == 0:
		print(l, l + 1, l + 2)
		return 0
	if r - l + 1 > 3:
		print(l + 1, l + 2, l + 3)
		return 0
	print(-1)
run()


import sys
I = sys.stdin.readline
(l, r) = map(int, I().split())
if l % 2 != 0:
	l += 1
if l + 2 > r:
	print(-1)
else:
	print(l, l + 1, l + 2)