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: interview

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)
# print(saisyo)
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)

# coding: utf-8
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())

#1～Nまでの最小公倍数+1が答え

#最小公約数を求める

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(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 > 1e13:
    X = X // 20 + 1
else:
    X += 1

print(X)

import sys
#from collections import deque
#from functools import lru_cache
#from fractions import Fraction as f
from copy import *
from bisect import *	
#from heapq import *
from math import gcd,ceil,sqrt
#from itertools import permutations as prm,product
#from random import *
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))

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

n = int(input())
ans = 2
for i in range(1, n+1):
    ans = lcm(ans, i)
print(ans + 1)

import math
n = int(input())
tem = 1

for i in range(1,n+1):
  tem = tem*i//(math.gcd(tem,i))
  
print(tem+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)

print("2329089562801")

def lcm(a, b):
    import math
    return math.floor(a*b/math.gcd(a, b))
N = int(input())
ans = 1
for i in range(2, N+1):
    ans = lcm(ans, i)
print(ans+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)

# print(dict(powers))
for key in keys:
    s *= (key ** powers[key])
s += 1
print(s)

# for i in range(2, n+1):
#     print(i, s % i)


# coding: utf-8
from math import gcd
def lcm(a, b):
    return a * b // gcd(a, b)

N = int(input())
ans = 1
for i in range(1, N+1):
    ans = lcm(ans, i)
print(2 * ans + 1)

print(2329089562801)

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

import math
n = int(input())

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

ans = 1
for i in range(1, n + 1):
    ans = lcm(i, ans)
print((ans + 1))


print(2329089562801)

print(2329089562801)

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


print(2329089562801)

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(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())
res = 1
for i in range(2, N+1):
    res = res*i//math.gcd(res, i)
print((res+1))


import math
N=int(input())

  #最小公倍数(least common multiple)を作る
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)

  


print(2329089562801)

print(2329089562801)

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)

from math import gcd
N = int(input())
r = 1
for i in range(2, N + 1):
    r = r / gcd(int(r), i) * i
print((int(r) + 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)

print(2329089562801)

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)]
  
#print (anslist)
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))


print(2329089562801)

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(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    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): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    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

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

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
#print=sys.stdout.write
#sys.setrecursionlimit(100000)
#from heapq import *
#from collections import deque as dq
from math import ceil,floor,sqrt,gcd,log
#import bisect as bs
#from collections import Counter
#from collections import defaultdict as dc 
#from functools import reduce
#from functools import lru_cache
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)

print(2329089562801)

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 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())
lst = [i for i in range(2, n + 1)]
print(lcm_list(lst) + 1)

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)


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

import math

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

n = int(input())
ans = 1
for i in range(2, n+1):
    ans = lcm(ans, i)
print(ans + 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)

def __starting_point():
    N = int(input())
    n = [i for i in range(2,N+1)]
    print(lcm_list(n)+1)
__starting_point()

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()
#from sys import setrecursionlimit
#setrecursionlimit(10**7)
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():
#====input code===
    n = int(input())
    ans = 1
    for i in range(1,n+1):
        ans = i * ans // gcd(i, ans)
    print(ans+1)
#================
resolve()

#n = int(input())
n = 30

# ２で割っても１余るため、Ansは必ず奇数 
# multi = 6*10*14*33*26*17*19*23*15*29
multi = 2 * 2 * 4 * 3 *  3 * 3 * 5 * 7* 11 *13 * 17 * 19 * 23 * 5 * 29 + 1
print(multi)
# multi = 10 ** 13 - 1
'''
num = 2
while num <= n:
    print(num, ',',multi%num)
    num += 1
'''




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


print(2329089562801)

print(2329089562801);

# -*- coding: utf-8 -*-
import math
from math import gcd

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


n = int(input())
ans = 2
for i in range(3, n+1):
    ans = lcm(ans, 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(a, b):
    return a // gcd(a, b) * b


n = input()
n = int(n)
ll = 2
for i in range(3, n + 1):
    ll = lcm(ll, i)
print((ll + 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)


import numpy as np
N=int(input())
x=1
for i in range(2,N+1):
    x=np.lcm(x,i)
print(x+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)

n = int(input())

from math import gcd
res = 1
for i in range(2,n+1):
    res = res*i//gcd(res,i)

print(res+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)

n=int(input())
def gcd(a,b):
  while b:
    a,b=b,a%b
  return a
def lcm(a,b):
  return a*b//gcd(a,b)
ans=2
for i in range(3, n + 1):
  ans=lcm(ans,i)
print(ans+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))

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

#
#
#
# 笑え、君が好きなように。
#                         笑いは世界を救う。
#                                           あなたが笑ってくれるなら。
#
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product, combinations_with_replacement # (string,3) 3回
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
# set型だと、 | と & が使えるよ
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
# 整数か判定する
# nanka.is_integer()
# ref https://atcoder.jp/contests/abc133/tasks/abc133_b
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
# mod = 9982443453
# mod = 998244353
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 statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product, combinations_with_replacement # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
# set型だと、 | と & が使えるよ
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
# 整数か判定する
# nanka.is_integer()
# ref https://atcoder.jp/contests/abc133/tasks/abc133_b
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
# mod = 9982443453
# mod = 998244353
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):
    """
    :param l: 最小公倍数を求めたいリスト
    :return: 最小公倍数
    """
    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)