Tavak and Seyyed are good friends. Seyyed is very funny and he told Tavak to solve the following problem instead of longest-path.

You are given l and r. For all integers from l to r, inclusive, we wrote down all of their integer divisors except 1. Find the integer that we wrote down the maximum number of times.

Solve the problem to show that it's not a NP problem.


-----Input-----

The first line contains two integers l and r (2 ≤ l ≤ r ≤ 10^9).


-----Output-----

Print single integer, the integer that appears maximum number of times in the divisors. 

If there are multiple answers, print any of them.


-----Examples-----
Input
19 29

Output
2

Input
3 6

Output
3



-----Note-----

Definition of a divisor: https://www.mathsisfun.com/definitions/divisor-of-an-integer-.html

The first example: from 19 to 29 these numbers are divisible by 2: {20, 22, 24, 26, 28}.

The second example: from 3 to 6 these numbers are divisible by 3: {3, 6}.

Difficulty: EASY

Solutions:
(a, b) = map(int, input().split())
print(2 if a != b else a)


(l, r) = map(int, input().split())
if l == r:
	print(l)
	exit(0)
print(2)


def fake_np():
	numbers = input().split()
	numbers = [int(i) for i in numbers]
	dic = {}
	if numbers[1] == numbers[0]:
		print(numbers[1])
		return
	print(2)
	return
	checking = numbers[1] - numbers[0]
	if checking > 1000:
		print(2)
		return
	maximum = 0
	output = 1
	for i in range(numbers[0], numbers[1]):
		temp = 2
		while True:
			if i % temp == 0:
				break
			else:
				temp += 1
		if temp not in dic:
			dic[temp] = 1
			if dic[temp] > maximum:
				maximum = dic[temp]
				output = temp
		else:
			dic[temp] += 1
			if dic[temp] > maximum:
				maximum = dic[temp]
				output = temp
	print(output)
fake_np()


(l, r) = input().split()
(l, r) = (int(l), int(r))
if l == r:
	print(l)
else:
	print(2)


import sys

def solve():
	(l, r) = map(int, input().split())
	if l == r:
		ans = l
	else:
		ans = 2
	print(ans)
solve()


segment = input().split()
segment = [int(x) for x in segment]
variation = segment[1] - segment[0]
if variation == 0:
	print(segment[0])
else:
	print(2)


(n, k) = map(int, input().split())
if n == k:
	print(n)
else:
	print(2)


import sys
from collections import deque
from collections import defaultdict
(L, R) = sys.stdin.readline().strip().split(' ')
L = int(L)
R = int(R)
counts = {}
max_divisor_count = 1
max_divisor = 1

def primes(n, counts):
	global max_divisor, max_divisor_count
	fac = set()
	d = 2
	print('n: {}'.format(n))
	while d <= n:
		while n % d == 0:
			print('d: {}'.format(d))
			if d not in fac:
				if d not in counts:
					counts[d] = 1
				else:
					counts[d] += 1
				if counts[d] > max_divisor_count:
					max_divisor_count = counts[d]
					max_divisor = d
				fac.add(d)
			n //= d
		d += 1
	if n > 1:
		fac.add(n)
	return fac
if R == L:
	print(R)
else:
	print(2)


def f(l, r):
	if l == r:
		return r
	return 2
x = input().split()
l = int(x[0])
r = int(x[1])
print(f(l, r))


(l, r) = (int(i) for i in input().split())
if l - r == 0:
	print(l)
else:
	print(2)


(l, r) = map(int, input().split(' '))
x = 2
if l == r:
	x = r
print(x)


s = input().split()
l = int(s[0])
r = int(s[1])
if l == r:
	print(l)
else:
	print(2)


def f(ll):
	(l, r) = ll
	return 2 if r > l else l
l = list(map(int, input().split()))
print(f(l))


(x, y) = map(int, input().split())
print(2 if x < y else x)


(a, b) = map(int, input().split())
two = three = five = seven = 0
if b - a > 0:
	print(2)
else:
	print(a)


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

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

def sq(a, target, arr=[]):
	s = sum(arr)
	if s == target:
		return arr
	if s >= target:
		return
	for i in range(len(a)):
		n = a[i]
		remaining = a[i + 1:]
		ans = sq(remaining, target, arr + [n])
		if ans:
			return ans

def SieveOfEratosthenes(n):
	cnt = 0
	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
	for p in range(2, n + 1):
		if prime[p]:
			cnt += 1
	return cnt

def nCr(n, r):
	f = math.factorial
	return f(n) // f(r) // f(n - r)
mod = int(1000000000.0) + 7

def ssinp():
	return input()

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

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

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

def p(xyz):
	print(xyz)

def p2(a, b):
	print(a, b)
import math
(l, r) = nninp()
if l == r:
	print(l)
else:
	print(2)


entrada = input()
a = int(entrada.split()[0])
b = int(entrada.split()[1])
if b > a:
	print(2)
else:
	print(a)


(l, r) = list(map(int, input().split()))
if l == r:
	print(l)
else:
	print(2)


(x, y) = map(int, input().split(' '))
c = d = 0
if x % 3 == 0 and y % 3 == 0:
	while 1:
		if x == y + 1:
			break
		if x % 2 == 0:
			c += 1
		if x % 3 == 0:
			d += 1
		x += 1
	if c >= d:
		print(2)
	else:
		print(3)
elif x == y:
	print(x)
else:
	print(2)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

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 main():
	(l, r) = LI()
	if l == r:
		return l
	return 2
print(main())


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

def I():
	return int(input())

def S():
	return str(input())

def L():
	return list(R())
from collections import Counter
import math
import sys
from itertools import permutations
(l, r) = R()
if l == r:
	print(l)
else:
	print('2')


(a, b) = tuple(input().split(' '))
if int(a) - int(b) == 0:
	print(a)
else:
	print('2')


(l, r) = [int(x) for x in input().split()]
(c2, c3) = (0, 0)
if l == r:
	print(l)
else:
	print(2)


(left, right) = map(int, input().split())
if left == right:
	print(left)
else:
	print(2)


(a, b) = list(map(int, input().split()))
if a == b:
	res = a
else:
	res = 2
print(res)


L = [int(x) for x in input().split()]
if L[0] == L[1]:
	print(L[0])
else:
	print(2)


(a, b) = map(int, input().split())
c = a % 2
if c != 0:
	c = a - c + 2
else:
	c = a
d = a % 3
if d != 0:
	d = a - d + 3
else:
	d = a
e = b % 2
if e != 0:
	e = b - e
else:
	e = b
f = a % 3
if f != 0:
	f = b - f
else:
	f = b
k1 = (e - c) // 2 + 1
k2 = (f - d) // 3 + 1
if a == b:
	print(a)
elif k1 >= k2:
	print(2)
else:
	print(3)


[k, p] = [int(i) for i in input().split()]
if k == p:
	print(k)
else:
	print(2)


(l, r) = list(map(int, input().split()))
if l != r:
	print(2)
else:
	for i in range(1, int(l ** 0.5) + 1):
		if i * (l // i) == l:
			print(l // i)
			break


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
d = defaultdict(int)
(l, r) = M()
if l == r:
	print(l)
else:
	print(2)


(l, r) = map(int, input().split())
(l1, r1) = (l, r)
if l == r:
	print(l)
else:
	print(2)


(l, r) = map(int, input().strip().split())
if l != r:
	print(2)
else:
	print(l)


def divisor(l, r):
	if l == r:
		return l
	else:
		return 2
(l, r) = list(map(int, input().split()))
print(divisor(l, r))


inp = input().split()
n = int(inp[0])
m = int(inp[1])
if n == m:
	print(n)
else:
	print(2)


import sys

def solve():
	(num1, num2) = map(int, input().split())
	if num1 == num2:
		print(num1)
	else:
		print(2)
solve()


def solve():
	(n, k) = map(int, input().split())
	if n == k:
		return n
	return 2
print(solve())


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

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

def pt(x):
	print(x)

def ip():
	return input()

def it():
	return int(input())

def sl(x):
	return [t for t in x]

def spl(x):
	return x.split()

def aj(liste, item):
	liste.append(item)

def bin(x):
	return '{0:b}'.format(x)

def listring(l):
	return ' '.join([str(x) for x in l])

def ptlist(l):
	print(' '.join([str(x) for x in l]))
(l, r) = mp()
if r != l:
	pt(2)
else:
	pt(r)


def main():
	(l, r) = input().strip().split()
	l = int(l)
	r = int(r)
	x = 0
	y = 0
	if l == r:
		print(l)
	else:
		print(2)
main()


(l, r) = [int(k) for k in input().split()]
if l != r:
	print(2)
else:
	print(l)


a = list(map(int, input().rstrip().split()))
if a[0] == a[-1]:
	print(a[0])
else:
	print('2')


(l, r) = list(map(int, input().split()))
print((l, 2)[l < r])


tmp = input()
tmp = tmp.split(' ')
l = int(tmp[0])
r = int(tmp[1])
if l == r:
	print(l)
else:
	print(2)


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


line = [int(l) for l in input().split(' ')]
if line[0] == line[1]:
	print(line[0])
else:
	print(2)


(l, r) = map(int, input().split())
(d, t) = (0, 0)
if l == r:
	print(l)
else:
	print(2)


l = input().split()
a = int(l[0])
a2 = int(l[1])
if a == a2:
	print(a)
else:
	print(2)


(L, R) = map(int, input().split())
if R != L:
	print(2)
else:
	print(L)


(l, n) = map(int, input().split())
if l == n:
	print(l)
else:
	print(2)


(n, m) = input().split()
if n == m:
	print(n)
else:
	print(2)


lis1 = [int(i) for i in input().split(' ')]
x = lis1[0]
y = lis1[1]
if x == y:
	print(x)
else:
	print(2)


a = list(map(int, input().split(' ')))
l = a[0]
r = a[1]
if l < r:
	print(2)
else:
	print(l)


def FakeNp(l, r):
	if l != r:
		return 2
	else:
		return l
(l, r) = [int(x) for x in input().split()]
print(FakeNp(l, r))


import math
(l, r) = [int(a) for a in input().split()]
if l == r:
	print(l)
else:
	print(2)


from math import sqrt

def primes(n):
	primfac = []
	boundry = int(sqrt(n)) + 1
	d = 2
	while d <= boundry:
		if n % d == 0:
			primfac.append(d)
		d += 1
	if n > 1:
		if n not in primfac:
			primfac.append(n)
	return primfac

def freq_factor():
	(l, r) = input().split()
	l = int(l)
	r = int(r)
	freqs = {}
	for v in range(l, r + 1):
		for f in primes(v):
			try:
				freqs[f] += 1
			except:
				freqs[f] = 1
	print(max(freqs.items(), key=lambda x: x[1])[0])
(l, r) = input().split()
l = int(l)
r = int(r)
if l == r:
	print(l)
else:
	print(2)


(n, m) = list(map(int, input().split()))
print([2, n][n == m])


values = input()
(a, b) = values.split()
a = int(a)
b = int(b)
if a == b:
	print(a)
else:
	print(2)


answer = 2
entrada = input().split(' ')
x = int(entrada[0])
xf = int(entrada[1])
if x == xf:
	answer = x
print(answer)


(l1, r) = map(int, input().split())
if l1 == r:
	print(l1)
else:
	print(2)


from math import ceil as c
(x, y) = map(int, input().split())
if x - y == 0:
	print(x)
elif x - y == 1:
	print(2)
else:
	two = c(abs(x - y) / 2) + min([(x + 1) % 2, (y + 1) % 2])
	three = abs(x - y + 1) // 3
	if x % 3 == 0 or y % 3 == 0:
		three += 1
	print(2 if two >= three else 3)


nums = list(map(int, list(input().split())))
if nums[0] == nums[1]:
	print(nums[0])
else:
	print(2)


line = input()
p = line.split()
l = int(p[0])
r = int(p[1])
if l == r:
	ans = l
else:
	ans = 2
print(ans)


import math
(n, l) = list(map(int, input().split()))
if n == l:
	print(l)
else:
	print(2)


import sys
import math

def main():
	(a, b) = map(int, sys.stdin.readline().strip().split()[:2])
	print(2 if a < b else a)
main()


(a, b) = A = list(map(int, input().split()))
if abs(a - b) > 0:
	print(2)
else:
	print(a)


(x, y) = input().split()
print(x if x == y else 2)


import sys

def main():
	(l, r) = map(int, sys.stdin.readline().split())
	if l == r:
		sol = l
	else:
		sol = 2
	print('%s' % sol)
main()


import sys
(l, r) = map(int, sys.stdin.readline().split())
ans = l
if l < r:
	ans = 2
print(ans)


(l, r) = map(int, input().split())
if abs(l - r) > 0:
	print(2)
else:
	print(l)


import math, string, itertools, collections, re, fractions, array, copy
import bisect
import heapq
from itertools import chain, dropwhile, permutations, combinations
from collections import deque, defaultdict, OrderedDict, namedtuple, Counter, ChainMap

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

def I():
	return int(input())

def LIST(n, m=None):
	return [0] * n if m is None else [[0] * m for i in range(n)]

def ELIST(n):
	return [[] for i in range(n)]

def MI(n=None, m=None):
	if n is None:
		(n, m) = VI()
	arr = LIST(n)
	for i in range(n):
		arr[i] = VI()
	return arr

def MS(n=None, m=None):
	if n is None:
		(n, m) = VI()
	arr = LIST(n)
	for i in range(n):
		arr[i] = input()
	return arr

def MIT(n=None, m=None):
	if n is None:
		(n, m) = VI()
	a = MI(n, m)
	arr = LIST(m, n)
	for (i, l) in enumerate(a):
		for (j, x) in enumerate(l):
			arr[j][i] = x
	return arr

def main(info=0):
	(l, r) = VI()
	if l == r:
		print(l)
		return
	print(2)

def __starting_point():
	main()
__starting_point()


s = input().split()
if s[0] == s[1]:
	print(s[0])
else:
	print(2)


a = input().split(' ')
if a[0] == a[1]:
	print(a[0])
else:
	print(2)


w = input().split()
l = eval(w[0])
r = eval(w[1])
if l == r:
	print(l)
else:
	print(2)


def main():
	(l, r) = tuple(map(int, input().split()))
	if l == r:
		print(l)
	else:
		print(2)
main()


lr = input()
lr = lr.split()
l = int(lr[0])
r = int(lr[1])
if l != r:
	print(2)
else:
	print(l)


import sys
fin = sys.stdin
fout = sys.stdout
(l, r) = map(int, fin.readline().split())
if l == r:
	print(l)
else:
	print(2)


(s1, s2) = input().split(' ')
(s1, s2) = (int(s1), int(s2))
count2 = 0
count3 = 0
if s2 - s1 == 0:
	print(s1)
elif s2 - s1 > 10000:
	print(2)
else:
	for n in range(s1, s2 + 1):
		if n % 2 == 0:
			count2 += 1
		if n % 3 == 0:
			count3 += 1
	if count2 >= count3:
		print(2)
	else:
		print(3)


(l, r) = map(int, input().split())
if l == r:
	print(l)
else:
	(l2, r2) = (l + l % 2, r - r % 2)
	(l3, r3) = (l + l % 3, r - r % 3)
	(ans1, ans2) = ((r2 - l2) // 2 + 1, 0)
	if r3 >= l3:
		ans2 = (r3 - l3) // 3 + 1
	print(2 if ans1 >= ans2 else 3)


a = list((int(x) for x in input().split()))
if a[0] == a[1]:
	print(a[0])
else:
	print(2)


l = input()
l = l.split()
a = int(l[0])
b = int(l[1])
if b - a == 0:
	print(a)
else:
	print(2)


from sys import stdin, stdout

def readint():
	return map(int, stdin.readline().split())
a = list(readint())
if a[0] == a[1]:
	print(a[0])
else:
	print(2)


import sys
inputNumber = input()
numbers = inputNumber.split(' ')
l = numbers[0]
r = numbers[1]
if l == r:
	print(l)
else:
	print('2')


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

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

def si():
	return input()

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

def msi():
	return map(str, input().strip().split(' '))

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

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
import sys
input = sys.stdin.readline
scanner = lambda : int(input())
string = lambda : input().rstrip()
get_list = lambda : list(read())
read = lambda : map(int, input().split())
get_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

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

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

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

def is_integer(n):
	return math.ceil(n) == math.floor(n)

def nCr(n, k):
	if k > n:
		return 0
	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 primefs(n):
	primes = {}
	while n % 2 == 0 and n > 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 and n > 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)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def next_prime(n, primes):
	while primes[n] != True:
		n += 1
	return n
MAXN = int(100000.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
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

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

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(beauty, s, n, count):
	pass
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
alphs = 'abcdefghijklmnopqrstuvwxyz'
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect

def solve():
	(l, r) = read()
	if l == r:
		print(r)
		return
	print(2)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

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


(L, R) = [int(n) for n in input().strip().split()]
if R - L > 0:
	print(2)
else:
	print(L)


s = [int(n) for n in input().split()]
if s[0] == s[1]:
	print(s[0])
else:
	print(2)


(a, b) = (int(i) for i in input().split())
if a == b:
	print(a)
else:
	print(2)


I = lambda : input().split()
(l, r) = map(int, I())
if l == r:
	print(l)
else:
	print(2)


(l, c) = input().split()
l = int(l)
c = int(c)
if l == c:
	print(l)
else:
	print('2')


def main():
	(l, r) = input().strip().split()
	l = int(l)
	r = int(r)
	if l == r:
		print(l)
	else:
		print(2)
main()


def divisores(n):
	arr = []
	u = n // 2 + 1
	for i in range(2, u + 1):
		if n % i == 0:
			arr.append(i)
	return arr

def divisor2(n):
	cont = 0
	while n > 0 and n % 2 == 0:
		n = n // 2
		cont += 1
	return cont
s = input().split(' ')
l = int(s[0])
r = int(s[1])
n = l - r + 1
a = []
if n == 1:
	print(l)
else:
	print(2)


s = list(map(int, input().split()))
if s[0] < s[1]:
	print(2)
else:
	print(s[0])


def Main():
	(a, b) = map(int, input().split())
	if a == b:
		print(a)
	else:
		print(2)

def __starting_point():
	Main()
__starting_point()


[low, up] = list(map(int, input().split()))
diff = up - low + 1
if diff == 1:
	print(low)
else:
	print(2)


def most_popular_divisor_in_range(x, y):
	if x == y:
		return x
	else:
		return 2

def solver():
	(x, y) = map(int, input().split())
	print(most_popular_divisor_in_range(x, y))
solver()


import math

def main():
	(l, r) = input().split()
	l = int(l)
	r = int(r)
	if l == r:
		print(r)
		return
	print(2)
main()


lista = []
entrada = str(input())
lista = entrada.split()
num1 = int(lista[0])
num2 = int(lista[1])
if num2 - num1 == 0:
	print(num1)
else:
	print('2')


class CodeforcesTask805ASolution:

	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):
		if self.l_r[1] > self.l_r[0]:
			self.result = '2'
		else:
			self.result = str(self.l_r[0])

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


import sys

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 == r:
	print(l)
else:
	print(2)


(l, r) = map(int, input().split())
q = 0
r1 = 0
if l == r:
	print(l)
elif r - l <= 1000:
	for i in range(l, r + 1):
		if i % 2 == 0:
			q = q + 1
		if i % 3 == 0:
			r1 = r1 + 1
	if q >= r1:
		print(2)
	else:
		print(3)
else:
	print(2)


n = input().split()
a = int(n[0])
b = int(n[1])
if a == b:
	print(a)
else:
	print('2')


TN = 1

def solution():
	(l, r) = map(int, input().split())
	print(l if l == r else 2)
while TN != 0:
	solution()
	TN -= 1


(x, y) = [int(x) for x in input().split()]
if x == y:
	print(x)
elif x > y:
	print(x)
else:
	print('2')


(L, R) = [int(i) for i in input().split()]
if L == R:
	print(L)
else:
	print(2)


string = input()
numbers = string.split()
a = int(numbers[0])
b = int(numbers[1])
if a == b:
	print(a)
else:
	print(2)


n = input('')
(l, r) = n.split()
if l == r:
	print(l)
else:
	print(2)


def main():
	(x, y) = map(int, input().split())
	if x == y:
		print(x)
	else:
		print(2)
	return
main()


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

def solve():
	(l, r) = map(int, input().split())
	if l == r:
		print(l)
	else:
		print(2)
tc = 1
for t in range(tc):
	solve()


def main():
	[left, right] = [int(_) for _ in input().split()]
	print(left if left == right else 2)
main()


a = input().split(' ')
x = int(a[0])
y = int(a[1])
n = y - x
if n >= 4:
	print(2)
elif n == 3:
	print(2)
elif n == 0:
	print(x)
else:
	print(2)


from collections import defaultdict
(L, R) = map(int, input().split())
print(2 if L != R else L)


X = list(map(int, input().split()))
print(X[0] if X[0] == X[1] else 2)


s = input().split(' ')
x = int(s[0])
y = int(s[1])
if x != y:
	print(2)
else:
	print(x)


from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt, gcd

def read_int():
	return int(input().strip())

def read_int_array():
	return [int(i) for i in input().strip().split(' ')]
(l, r) = read_int_array()
if l < r:
	print(2)
else:
	print(l)


(l, r) = map(int, input().rstrip().split(' '))
if l == r:
	print(l)
else:
	print(2)


(n, m) = [int(x) for x in input().split()]
if n == m:
	print(n)
else:
	print(2)


(b, m) = map(int, input().split())
if b == m:
	print(b)
else:
	print(2)


numbers = list(map(int, input().split()))
if numbers[0] == numbers[1]:
	print(numbers[0])
else:
	print('2')


from sys import maxsize, stdout, stdin, stderr
import re
tup = lambda : map(int, stdin.readline().split())
I = lambda : int(stdin.readline())
lint = lambda : [int(x) for x in stdin.readline().split()]
S = lambda : stdin.readline().replace('\n', '').strip()

def grid(r, c):
	return [lint() for i in range(r)]

def debug(*args, c=6):
	print('\x1b[3{}m'.format(c), *args, '\x1b[0m', file=stderr)
(l, r) = tup()
if l == r:
	print(l)
else:
	print(2)


(p, q) = map(int, input().split())
if p == q:
	print(p)
else:
	print(2)


import sys
import math
(l, r) = map(int, input().split())
if l != r:
	print(2)
else:
	print(l)


def __starting_point():
	(l, r) = list(map(int, input().split()))
	if l == r:
		print(l)
	else:
		print(2)
__starting_point()


arr = list(map(int, input().split()))
if arr[0] == arr[1]:
	print(arr[0])
else:
	print('2')


f = lambda : map(int, input().split())
(a, b) = f()
print([2, a][a == b])


import sys
import math
import bisect
import itertools
import random
import re

def main():
	(l, r) = map(int, input().split())
	if l == r:
		print(l)
	else:
		print(2)
main()


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


(l, r) = map(int, input().split())
total = r - l + 1
c2 = total // 2
c3 = total // 3
if total == 1:
	print(l)
elif c2 >= c3:
	print(2)


user_input = input().split()
(l, r) = (int(user_input[0]), int(user_input[1]))
if l == r:
	print(l)
else:
	print(2)


T = input()
T = T.split()
A = int(T[0])
B = int(T[1])
if A == B:
	print(A)
else:
	print(2)


buff = input().split()
l = int(buff[0])
r = int(buff[1])
result = 2
if l == r:
	result = l
print(result)


from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

def getInt():
	return int(input())

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

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

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

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
(a, b) = zzz()
rem = b - a
print(2 if rem else a)


(l, r) = map(int, input().split())
d = r - l
two = d // 2
three = d // 3
if l == r:
	print(l)
elif two >= three:
	print(2)
else:
	print(3)


buf = input()
a = buf.split()
l = int(a[0])
r = int(a[1])
if r == l:
	print(l)
else:
	print(2)


l1 = input().split()
l1 = [int(i) for i in l1]
if l1[0] == l1[1]:
	print(min(l1[0], l1[1]))
else:
	print('2')