We have an integer N.
Print an integer x between N and 10^{13} (inclusive) such that, for every integer y between 2 and N (inclusive), the remainder when x is divided by y is 1.
Under the constraints of this problem, there is always at least one such integer x.

-----Constraints-----
 - All values in input are integers.
 - 2 \leq N \leq 30

-----Input-----
Input is given from Standard Input in the following format:
N

-----Output-----
Print an integer x between N and 10^{13} (inclusive) such that, for every integer y between 2 and N (inclusive), the remainder when x is divided by y is 1.
If there are multiple such integers, any of them will be accepted.

-----Sample Input-----
3

-----Sample Output-----
7

The remainder when 7 is divided by 2 is 1, and the remainder when 7 is divided by 3 is 1, too.
7 is an integer between 3 and 10^{13}, so this is a desirable output.

Difficulty: MEDIUM_HARD

Starter code:

Solutions:
import math
from functools import reduce
N = int(input())

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm(*numbers):
	return reduce(lcm_base, numbers, 1)
A = []
for i in range(2, N + 1):
	A.append(i)
X = lcm(*A) + 1
print(X)


import math
import numpy as np
import sys
input = sys.stdin.readline

def main():
	n = int(input())
	ans = 1
	for i in range(1, n + 1):
		ans = ans * i // math.gcd(ans, i)
	print(ans + 1)
main()


n = int(input())
l = [3, 7, 9, 11, 13, 16, 17, 19, 23, 25, 29]
a = 1
for i in l:
	a *= i
print(a + 1)


N = int(input())
factor = set([2, 3, 4, 5, 7, 9, 10, 11, 13, 17, 19, 23, 29])
res = 1
for i in range(2, N + 1):
	if i in factor:
		res *= i
print(res + 1)


import fractions
n = int(input())
ans = 2
for i in range(2, n + 1):
	ans = ans * i // fractions.gcd(ans, i)
print(ans + 1)


import math
from functools import reduce
N = int(input())
saisyo = []
for a in range(2, N + 1):
	saisyo.append(a)

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm(*numbers):
	return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
	return reduce(lcm_base, numbers, 1)
print(lcm_list(saisyo) + 1)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
N = int(input())
ans = 1
for i in range(2, N + 1):
	ans = lcm(ans, i)
ans = 2 * ans + 1
print(ans)


import math
n = int(input())
a = 1
for i in range(1, n + 1):
	a *= i // math.gcd(a, i)
print(a + 1)


from math import gcd
n = int(input())
sum = 1
for i in range(2, n + 1):
	sum = sum * i // gcd(sum, i)
print(sum + 1)


print(2329089562801)


N = int(input())
pp = [1, 2, 3, 2, 5, 1, 7, 2, 3, 1, 11, 1, 13, 1, 1, 2, 17, 1, 19, 1, 1, 1, 23, 1, 5, 1, 3, 1, 29, 1]
pN = 1
for i in range(1, N + 1):
	pN *= pp[i - 1]
print(pN + 1)


N = int(input())

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

def lcm(a, b):
	return int(a * b / gcd(a, b))
ans = 2
for i in range(3, N + 1):
	ans = lcm(ans, i)
print(ans + 1)


n = int(input())
d = {}
for i in range(2, 31):
	d[i] = 0
for i in range(2, n + 1):
	s = {}
	for j in range(2, 31):
		s[j] = 0
	x = i
	for j in range(2, i + 1):
		while x % j == 0 and x >= j:
			s[j] += 1
			x /= j
	for j in range(2, n + 1):
		if s[j] > d[j]:
			d[j] = s[j]
ans = int(1)
for i in range(2, n + 1):
	ans *= i ** d[i]
print(ans + 1)


N = int(input())
X = 1
for i in range(2, N + 1):
	if X % i == 0:
		continue
	else:
		X *= i
if X > 10000000000000.0:
	X = X // 20 + 1
else:
	X += 1
print(X)


import sys
from copy import *
from bisect import *
from math import gcd, ceil, sqrt

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
sys.setrecursionlimit(10 ** 5)
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')
di = [[-1, 0], [1, 0], [0, 1], [0, -1]]

def string(s):
	return ''.join(s)

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

def inc(d, c, x=1):
	d[c] = d[c] + x if c in d else x

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

def fli():
	return [float(x) for x in input().split()]

def comp(a, b):
	if a > b:
		return 2
	return 2 if a == b else 0

def gi():
	return [xx for xx in input().split()]

def gtc(tc, ans):
	print('Case #' + str(tc) + ':', ans)

def cil(n, m):
	return n // m + int(n % m > 0)

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def si():
	return list(input().rstrip())

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

def gh():
	sys.stdout.flush()

def isvalid(i, j, n, m):
	return 0 <= i < n and 0 <= j < m

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = 1
while t > 0:
	t -= 1
	n = fi()
	l = 1
	for i in range(2, n + 1):
		l = l * i // gcd(l, i)
	print(l + 1)


import math
N = int(input())
gcd = 1
for i in range(2, N + 1):
	gcd = gcd * i // math.gcd(gcd, i)
print(gcd + 1)


import sys
from collections import defaultdict
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7

def prime_factorize(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr

def main():
	N = int(readline())
	d = defaultdict(int)
	for i in range(2, N + 1):
		P = prime_factorize(i)
		for (x, n) in P:
			d[x] = max(d[x], n)
	ans = 1
	for (x, n) in list(d.items()):
		ans *= x ** n
	ans += 1
	print(ans)

def __starting_point():
	main()
__starting_point()


import math

def lcm(x, y):
	return x * y // math.gcd(x, y)
n = int(input())
num = 1
for i in range(2, n + 1):
	num = lcm(num, i)
print(num + 1)


n = int(input())
j = 2
v = 2

def johou(a, b):
	mx = max(a, b)
	mn = min(a, b)
	while True:
		tmp = mn
		mn = mx % mn
		mx = tmp
		if mn == 0:
			return mx
			break
for i in range(2, n + 1):
	j = johou(v, i)
	v = i * v / j
print(int(v + 1))


from math import gcd
N = int(input())
a = []
ele = 0
for i in range(2, N + 1):
	ele = ele + i
	a.append(ele)
	ele = 0
b = a
lcm = b[0]
for i in b[1:]:
	lcm = lcm * i // gcd(lcm, i)
print(lcm + 1)


import math
from functools import reduce

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm_list(numbers):
	return reduce(lcm_base, numbers, 1)
N = int(input())
numList = list(range(2, N + 1))
ans = lcm_list(numList) + 1
print(ans)


n = int(input())

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
ans = 1
for i in range(2, n + 1):
	ans = ans * i // gcd(ans, i)
print(ans + 1)


import sys
import logging
import math
from functools import reduce

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

def lcm_list(numbers):
	return reduce(lcm, numbers)

def main():
	n = int(input())
	ans = lcm_list(list(range(2, n + 1)))
	print(ans + 1)

def __starting_point():
	if len(sys.argv) >= 2 and sys.argv[1] == '--debug':
		loglevel = 'debug'
	else:
		loglevel = 'warning'
	numeric_level = getattr(logging, loglevel.upper(), None)
	if not isinstance(numeric_level, int):
		raise ValueError('Invalid log level: %s' % loglevel)
	logging.basicConfig(level=numeric_level, format='%(levelname)s (%(asctime)s.%(msecs)d): %(message)s', datefmt='%I:%M:%S')
	main()
__starting_point()


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

def gcm_2(a, b):
	Gcm = gcm(a, b)
	return a * b / Gcm
N = int(input())
ans = 2
for i in range(3, N + 1):
	ans = gcm_2(ans, i)
ans += 1
print(int(ans))


from collections import defaultdict
n = int(input())
s = 1
keys = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
powers = defaultdict(lambda : 0)
for i in range(2, n + 1):
	for key in keys:
		x = i
		cur = 0
		while x > 0 and x % key == 0:
			x //= key
			cur += 1
		powers[key] = max(powers[key], cur)
for key in keys:
	s *= key ** powers[key]
s += 1
print(s)


from math import gcd
from sys import stdin
pin = stdin.readline

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

def main():
	N = int(pin())
	k = 2
	for i in range(3, N + 1):
		k = lcm(k, i)
	print(k + 1)
	return
main()


n = int(input())

def gcd(u, v):
	if u < v:
		return gcd(v, u)
	if v == 0:
		return u
	return gcd(v, u % v)
x = 1
for i in range(1, n + 1):
	x = i // gcd(x, i) * x
print(x + 1)


N = int(input())
fac = [i + 2 for i in range(N - 1)]
num = 1
for i in range(N - 1):
	num = num * fac[i]
	fac = [x // fac[i] if x % fac[i] == 0 else x for x in fac]
print(num + 1)


N = int(input())

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

def factor(n):
	tmp = n
	out = [0] * len(prime_nums)
	i = 0
	while tmp != 1:
		if tmp % prime_nums[i] == 0:
			tmp = tmp // prime_nums[i]
			out[i] += 1
		else:
			i += 1
	return out
prime_nums = [k for k in range(2, N + 1) if prime_check(k)]
memo = []
for i in range(1, N + 1):
	memo.append(factor(i))
record = [0] * len(prime_nums)
for p in range(len(prime_nums)):
	for j in range(N):
		record[p] = max(record[p], memo[j][p])
ans = 1
for i in [b ** a for (a, b) in zip(record, prime_nums)]:
	ans *= i
print(ans + 1)


import math
N = int(input())
prime_factor = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

def find_prime_factor(n, ans):
	for i in prime_factor:
		ni = 0
		nn = n
		while nn % i == 0:
			ni += 1
			nn /= i
		if ans[i] < ni:
			ans[i] = ni
	return ans
ans = dict(list(zip(prime_factor, [0] * len(prime_factor))))
for i in range(2, N + 1):
	ans = find_prime_factor(i, ans)
ret = 1
for i in ans:
	ret = ret * i ** ans[i]
ret += 1
print(ret)


import math
n = int(input())
ans = 1
for i in range(1, n + 1):
	if ans % i != 0:
		a = math.gcd(ans, i)
		ans *= i // a
ans += 1
print(ans)


N = int(input())
import math

def lcm(x, y):
	return x * y // math.gcd(x, y)
g = 1
for i in range(2, N + 1):
	g = lcm(g, i)
print(g + 1)


import numpy as np
n = int(input())
x = 1
for i in range(2, n + 1):
	x = np.lcm(x, i)
print(x + 1)


n = int(input())
l = [0, 1, 2, 3, 2, 5, 1, 7, 2, 3, 1, 11, 1, 13, 1, 1, 2, 17, 1, 19, 1, 1, 1, 23, 1, 5, 1, 3, 1, 29, 1]
product = 1
for i in range(1, n + 1):
	product *= l[i]
print(product + 1)


from math import gcd
n = int(input())
l = 1
for i in range(1, n + 1):
	l = l * i // gcd(l, i)
print(l + 1)


from functools import reduce
import math

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm_list(numbers):
	return reduce(lcm_base, numbers, 1)
n = int(input())
n_list = []
for i in range(n - 1):
	n_list.append(i + 2)
print(lcm_list(n_list) + 1)


import numpy as np
n = int(input())
x = np.lcm.reduce(list(range(2, n + 1)), dtype=np.int64) + 1
print(x)


input()
print(16 * 27 * 25 * 7 * 11 * 13 * 17 * 19 * 23 * 29 + 1)


import math
from functools import reduce

def lcm(x, y):
	return x * y // math.gcd(x, y)

def lcm_list(numbers):
	return reduce(lcm, numbers, 1)
N = int(input())
anslist = [i for i in range(2, N + 1)]
L = lcm_list(anslist)
print(L + 1)


import math
n = int(input())
ans = 1
p = [7, 11, 13, 17, 19, 23, 29]
for j in p:
	if j > n:
		break
	ans *= j
ans *= 2 ** math.floor(math.log(n, 2)) * 3 ** math.floor(math.log(n, 3)) * 5 ** math.floor(math.log(n, 5))
print(ans + 1)


import sys
from math import gcd
read = sys.stdin.buffer.read
x = 1
for n in range(1, 31):
	x = x // gcd(x, n) * n
print(x + 1)


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

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

def lcml(a):
	if len(a) == 1:
		return a[0]
	else:
		return lcm(a[0], lcml(a[1:]))
n = int(input())
print(lcml(list(range(2, n + 1))) + 1)


import sys, collections as cl, bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10 ** 9 + 7
Max = sys.maxsize

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

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

def onem():
	return int(input())

def s(x):
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x) - 1):
		if aa != x[i + 1]:
			a.append([aa, su])
			aa = x[i + 1]
			su = 1
		else:
			su += 1
	a.append([aa, su])
	return a

def jo(x):
	return ' '.join(map(str, x))

def max2(x):
	return max(map(max, x))

def In(x, a):
	k = bs.bisect_left(a, x)
	if k != len(a) and a[k] == x:
		return True
	else:
		return False

def pow_k(x, n):
	ans = 1
	while n:
		if n % 2:
			ans *= x
		x *= x
		n >>= 1
	return ans
import math
from functools import reduce

def gcd(*numbers):
	return reduce(math.gcd, numbers)

def gcd_list(numbers):
	return reduce(math.gcd, numbers)

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm(*numbers):
	return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
	return reduce(lcm_base, numbers, 1)
n = onem()
ans = 1
for i in range(1, n + 1):
	ans = lcm(ans, i)
print(ans + 1)


import sys
input = sys.stdin.readline
from math import ceil, floor, sqrt, gcd, log
ri = lambda : int(input())
rl = lambda : list(map(int, input().split()))
rs = lambda : input()
for _ in range(1):
	N = ri()
	ans = 1
	for i in range(2, N + 1):
		ans = ans * i // gcd(ans, i)
	print(ans + 1)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
n = int(input())
a = 2
for i in range(3, n + 1):
	a = lcm(a, i)
print(a + 1)


n = int(input())
a = 1
from math import gcd
for i in range(2, n + 1):
	if a % i:
		g = gcd(a, i)
		a = a * i // g
print(a + 1)


import math
n = int(input())

def fun(x, y):
	return x * y // math.gcd(x, y)
ans = 1
for i in range(1, n + 1):
	ans = fun(ans, i)
print(ans + 1)


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

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

def main():
	N = int(input())
	n = lcm(2, 3)
	for i in range(4, N + 1):
		if N == 2:
			print(3)
		elif N == 3:
			print(7)
		else:
			n = lcm(n, i)
	print(n + 1)

def __starting_point():
	main()
__starting_point()


import fractions
n = int(input())
a = list(range(2, n + 1))

def gcd(x, y):
	if y == 0:
		return x
	else:
		return gcd(y, x % y)
ans = a[0]
for i in range(n - 1):
	ans = ans * a[i] // fractions.gcd(ans, a[i])
print(ans + 1)


import math
N = int(input())
arr = [0] * (N + 1)
for i in range(2, N + 1):
	num = i
	for j in range(2, N + 1):
		count = 0
		while num % j == 0:
			num /= j
			count += 1
		arr[j] = max(arr[j], count)
ans = 1
for (j, v) in enumerate(arr):
	if v != 0:
		ans *= pow(j, v)
ans += 1
print(ans)


from collections import defaultdict

def factorize(n: int) -> dict:
	f = defaultdict(int)
	while n % 2 == 0:
		f[2] += 1
		n //= 2
	p = 3
	while p * p <= n:
		while n % p == 0:
			f[p] += 1
			n //= p
		p += 2
	if n != 1:
		f[n] += 1
	return f
n = int(input())
ans = 1
for i in range(1, n + 1):
	f_ans = factorize(ans)
	f_i = factorize(i)
	for (k, v) in list(f_i.items()):
		if f_ans[k] < v:
			ans *= pow(k, v - f_ans[k])
ans += 1
print(ans)


N = input()
print(2329089562801)


from itertools import accumulate, chain, combinations, groupby, permutations, product
from collections import deque, Counter
from bisect import bisect_left, bisect_right
from math import gcd, sqrt, sin, cos, tan, degrees, radians
from fractions import Fraction
from decimal import Decimal
from functools import reduce
import sys
input = lambda : sys.stdin.readline().rstrip()
MOD = 10 ** 9 + 7
INF = float('inf')

def lcm_base(x, y):
	return x * y // gcd(x, y)

def lcm(*numbers):
	return reduce(lcm_base, numbers, 1)
n = int(input())
print(1 + lcm(*list(range(2, n + 1))))


n = int(input())
tmp = 2

def gcd(a, b):
	if a % b == 0:
		return b
	else:
		return gcd(b, a % b)
for i in range(3, n + 1):
	tmp = tmp * i // gcd(tmp, i)
print(tmp + 1)


print(8 * 9 * 5 * 29 * 23 * 19 * 17 * 13 * 11 * 7 * 5 * 3 * 2 + 1)


print(25200 * 11 * 3 * 17 * 19 * 23 * 29 * 13 + 1)


from math import gcd

def resolve():
	n = int(input())
	ans = 1
	for i in range(1, n + 1):
		ans = i * ans // gcd(i, ans)
	print(ans + 1)
resolve()


n = 30
multi = 2 * 2 * 4 * 3 * 3 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 5 * 29 + 1
print(multi)


import fractions
N = int(input())
a = []
for i in range(2, N + 1):
	a.append(i)
ans = a[0]
for i in range(1, N - 1):
	ans = ans * a[i] // fractions.gcd(ans, a[i])
print(ans + 1)


def find_lcm(num1, num2):
	if num1 > num2:
		num = num1
		den = num2
	else:
		num = num2
		den = num1
	rem = num % den
	while rem != 0:
		num = den
		den = rem
		rem = num % den
	gcd = den
	lcm = int(int(num1 * num2) / int(gcd))
	return lcm
n = int(input())
arr = [i for i in range(1, n + 1)]
lcm = find_lcm(arr[0], arr[1])
i = 2
while i < n:
	lcm = find_lcm(lcm, arr[i])
	i += 1
print(lcm + 1)


N = int(input())
print(2 ** 4 * 3 ** 3 * 5 ** 2 * 7 * 11 * 13 * 17 * 19 * 23 * 29 + 1)


from math import gcd

def lcm(x, y):
	return x * y // gcd(x, y)

def arr_lcm(arr):
	if len(arr) == 2:
		return lcm(arr[0], arr[1])
	return lcm(arr[0], arr_lcm(arr[1:]))
n = int(input())
print(arr_lcm([i for i in range(1, n + 1)]) + 1)


from functools import reduce

def GCD(a: int, b: int) -> int:
	return a if b == 0 else GCD(b, a % b)

def LCM(a: int, b: int) -> int:
	return a * b // GCD(a, b)
n = int(input())
ans = reduce(LCM, list(range(1, n + 1))) + 1
print(ans)


def main():
	n = int(input())
	primes = dict()
	ans = 1
	for i in range(2, n + 1):
		t = i
		j = 2
		while j * j <= t:
			k = 0
			while t % j == 0:
				t //= j
				k += 1
			if k != 0:
				if j in primes:
					primes[j] = max(primes[j], k)
				else:
					primes[j] = k
			j += 1
		if t != 1:
			if t in primes:
				primes[t] = max(primes[t], 1)
			else:
				primes[t] = 1
	for (i, t) in list(primes.items()):
		ans *= i ** t
	print(ans + 1)

def __starting_point():
	main()
__starting_point()


from fractions import gcd
n = int(input())
kotae = 1
for i in range(2, n + 1):
	kotae = kotae * i // gcd(kotae, i)
print(kotae + 1)


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

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

def main():
	N = int(input())
	y = 1
	for x in range(2, N + 1):
		y = lcm(y, x)
	print(y + 1)

def __starting_point():
	main()
__starting_point()


import math
n = int(input())
common = 1
for num in range(1, n + 1):
	common = common * num // math.gcd(common, num)
print(common + 1)


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

def lcm(a, b):
	return a * b / gcd(a, b)
n = int(input())
l = n
for i in range(2, n):
	l = lcm(l, i)
print(int(l + 1))


from math import gcd
from itertools import combinations, permutations, accumulate, product, combinations_with_replacement
from collections import deque, defaultdict, Counter
import decimal
import re
import math
import bisect
import heapq
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
INF = float('inf')
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
from sys import stdin
readline = stdin.readline

def readInts():
	return list(map(int, readline().split()))

def readTuples():
	return tuple(map(int, readline().split()))

def I():
	return int(readline())

def f(n):
	return int(math.ceil(n - 0.5))
from math import gcd
from itertools import combinations, permutations, accumulate, product, combinations_with_replacement
from collections import deque, defaultdict, Counter
import decimal
import re
import math
import bisect
import heapq
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
INF = float('inf')
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
from sys import stdin
readline = stdin.readline

def readInts():
	return list(map(int, readline().split()))

def readTuples():
	return tuple(map(int, readline().split()))

def I():
	return int(readline())

def f(n):
	return int(math.ceil(n - 0.5))

def fPI():
	return math.pi
N = I()
lcm = 1
for i in range(2, N + 1):
	g = gcd(lcm, i)
	lcm = lcm * i // g
print(lcm + 1)


import math
from functools import reduce

def lcm_base(x, y):
	return x * y // math.gcd(x, y)

def lcm(l):
	return reduce(lcm_base, l)
N = int(input())
l = [i for i in range(2, N + 1)]
lcm_num = lcm(l)
print(lcm_num + 1)