Harryxun/stf_run huggingface dataset:
N = int(raw_input())

if N == 1:
    print 'Hello World'
else:
    A = int(raw_input())
    B = int(raw_input())
    print str(A+B)




### FIXED CODE ###

N = int(raw_input())

if N == 1:
    print 'Hello World'
else:
    A = int(raw_input())
    B = int(raw_input())
    print str(A+B)
from math import gcd
n,x = map(int,input().split())
l = [int(ele) for ele in input().split()]
l.append(x)
l.sort()
g = 0 
for i in range(1,n+1):
    g = gcd(g,l[i]-l[i-1])
print(g)


### FIXED CODE ###

def gcd(a,b):
    if b==0:
        return a 
    return gcd(b,a%b)
n,x = map(int,input().split())
l = [int(ele) for ele in input().split()]
l.append(x)
l.sort()
g = 0 
for i in range(1,n+1):
    g = gcd(g,l[i]-l[i-1])
print(g)
import numpy as np
N, M, C = [int(x) for x in input().split()]
B = np.array([int(x) for x in input().split()])
A = np.array([[int(x) for x in input().split()] for _ in range(N)])
 
print(np.sum(A.dot(B) > -C))

### FIXED CODE ###

N, M = [int(x) for x in input().split()]
AB = [[int(x) for x in input().split()] for _ in range(N)]
AB.sort(key=lambda x: x[0])

s = 0
for ab in AB:
    if ab[1] > M:
        s += M*ab[0]
        break
    else:
        s += ab[0]*ab[1]
        M -= ab[1]

print(s)
n = int(input())
a=[]

b = list(map(int, input().split()))
for i in range(n):
    4a+=[[i+1, b[i]] ]
    
    
import operator as op
a.sort(key = op.itemgetter(1))

x=""
for i in range(n):
    x+=str(a[i][0])
    if i!=n-1:
        x+=" "
#a = [[3,-9],[2,3],[1,20]]
print(x)

### FIXED CODE ###

n = int(input())
a=[]

b = list(map(int, input().split()))
for i in range(n):
    a+=[[i+1, b[i]] ]
    
    
import operator as op
a.sort(key = op.itemgetter(1))

x=""
for i in range(n):
    x+=str(a[i][0])
    if i!=n-1:
        x+=" "

print(x)
N=int(input())
sisterN=[]
SISTERn=[]
SIStern=[]
for n in range(N):
    _=int(input())
    if _<40000:
        _s= _
        if sisterN.count(_s)==1:
            sisterN.remove(_s)
        else:
            sisterN.append(_s)
    elif 40001<_<99000:
        _m= _
        if SISterN.count(_m)==1:
            SISterN.remove(_m)
        else:
            SISterN.append(_m)
    else:
        _b= _
        if SISTERn.count(_b)==1:
            SISTERn.remove(_b)
        else:
            SISTERn.append(_b)

print(len(sisterN)+len(SISTERn)+len(SIStern))

### FIXED CODE ###

N=int(input())
S=set()

for n in range(N):
    _=int(input())
    if _ in S:
        S.remove(_)
    else:
        S.add(_)

print(len(S))
N = input()
A = [int(x) for x in input().split()]

a=1
b=False
for i in range(N):
    a=a*A[i]
    if a>10^18:
        b=True
        continue

if b==False:
    print(a)
else:
    print(-1)




### FIXED CODE ###

def main():
    N = int(input())
    A = list(map(int,input().split()))
    if 0 in A:
        print(0)
        return
    prod = 1
    for a in A:
        prod *= a
        if prod > 1000000000000000000:
            print(-1)
            return
    print(prod)
    
main()
i = int(input())
num = map(int, input().split())
count = 0
while True:
  if(type(sum(num/2)) == "float"):
    break
  count += 1
print(count)

### FIXED CODE ###

i = int(input())
num = list(map(int, input().split()))
count = 0
while True:
  flag = False
  for k in range(i):
    if num[k] % 2 != 0:
      flag = True
  if flag:
    break
  for k in range(i):
    num[k] /= 2
  count += 1
print(count)
import copy

n = int(input())
#res = []
table = ['a']

def dfs(s, time, table):
    tab = copy.deepcopy(table)
    l = len(tab)
    mi = ord(s[0])
    for i in range(time):
        if mi < ord(s[i]):
            mi = ord(s[i])
            if s[i] in tab:
                 pass
            else:
                tab.append(s[i])
    mi += 1
    
    if time == n:
        #print(tab)
        if s in res:
            pass
        else:
            #res.append(s)
            print(s)
    else:
        #dfs(s+chr(mi), time+1, tab)
        for i in range(l):
            dfs(s+tab[i], time+1, tab)
        dfs(s+chr(mi), time+1, tab)
            
dfs('a', 1, table)

#res.sort()
#for i in range(len(res)):
#    print(res[i])

### FIXED CODE ###

n = int(input())
lis = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]

for i in range(1, 33):
    if i == n:
        print(lis[i-1])
n=input()
p=input()
p=p.split()
q=[]
for i in range(int(n)):
    if min(p[:i+1])==p[i]:
        q.append(p[i])
print(len(q))

### FIXED CODE ###

a=input()
b=a.split()
if int(b[0])==int(b[1]):
  print('Yes')
else:
  print('No')
def factorization(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(cnt)
    if temp!=1:
        arr.append(1)
    if arr==[]:
        arr.append(1)
    return arr

def calc(n):
    val = 1
    count = 0
    for i in range(2,100000):
        count += 1
        val = val + i
        if val > n:
            return count

N = int(input())
if N == 1:
    print(0)
    exit(0)

print(arr)

ans = 0 
for val in arr:
    ans += calc(val)
 
print(ans)

### FIXED CODE ###


def factorization(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(cnt)
    if temp!=1:
        arr.append(1)
    if arr==[]:
        arr.append(1)
    return arr

def calc(n):
    val = 1
    count = 0
    for i in range(2,100000):
        count += 1
        val = val + i
        if val > n:
            return count

N = int(input())
if N == 1:
    print(0)
    exit(0)

arr = factorization(N)

ans = 0 
for val in arr:
    ans += calc(val)
 
print(ans)
a,b = map(int,input().split())
if a<b:
  print(2*b-1)
elif a=b:
  print(2*a)
else:
  print(2*a-1)

### FIXED CODE ###

a,b = map(int,input().split())
if a<b:
  print(2*b-1)
elif a==b:
  print(2*a)
else:
  print(2*a-1)
# import bisect
# from collections import Counter, deque
# import copy
# from fractions import gcd
# from functools import reduce
from itertools import permutations
# import math
import numpy as np
input = sys.stdin.readline

def resolve():
    N=int(input())
    l=[[0,0] for i in range(N)]
    for i in range(N):
        x,y=map(int,input().split())
        l[i][0],l[i][1]=x,y

    p=permutations(l)
    dist = 0
    for v in p:
        for i in range(N-1):
            dist+=np.sqrt((v[i][0]-v[i+1][0])**2+(v[i][1]-v[i+1][1])**2)
    print(dist/len(list(permutations((l)))))


resolve()

### FIXED CODE ###

# import bisect
# from collections import Counter, deque
# import copy
# from fractions import gcd
# from functools import reduce
from itertools import permutations

def resolve():
    N=int(input())
    l=[[0,0] for i in range(N)]
    for i in range(N):
        x,y=map(int,input().split())
        l[i][0],l[i][1]=x,y

    p=permutations(l)
    dist = 0
    for v in p:
        for i in range(N-1):
            dist+=((v[i][0]-v[i+1][0])**2+(v[i][1]-v[i+1][1])**2)**0.5

    print(dist/len(list(permutations((l)))))


resolve()
N,A,B = map(int,input().split())
C = N//(A+B)
D = N%(A+B)
print(C*A+min(D,A))

### FIXED CODE ###

N = input()
if N == "AAA" or N == "BBB":
    print("No")
else:
    print("Yes")
n=int(input())
num=[]
i=0
while n>0
  num.add(int(input()))
  n -= 1
while True:
  for j in num:
    if j%2==1:
      print(i)
      break
    else:
      j=j/2
  i += 1    

### FIXED CODE ###

n=int(input())
i=0
num=input().split()
t=True
while t==True:
  for j in range(n):
    if int(num[j])%2==1:
      t=False
      break
    else:
      num[j]=int(num[j])/2
  i += 1
print(i-1)
N = int(input())
for i in range(N):
    a = list(map(int,input().split())) 
A = set(a)
B = sorted(A)
C = []
for i in range(len(A)):
    C.append(B[i+1]-B[i])
print(sum(C))

### FIXED CODE ###

N = int(input())
a = list(map(int,input().split())) 
A = set(a)
B = sorted(A)
C = []
for i in range(len(A)-1):
    C.append(B[i+1]-B[i])
print(sum(C))
a ,b= map(int,input().split())
#S = int(input())

if a > b:
    ans = [str(b)]*a
    ans = "".join(ans)
else:
    ans = [str(a)]*b
    ans = "".join(ans)
print(ans)

### FIXED CODE ###

N = int(input())
P = list(map(int,input().split()))
c = 1
minN =P[0]
for x in range(1,N):
    if P[x]<= minN:
        c +=1
        minN = P[x]
print(c)
import bisect
import sys
mod=998244353
n=int(input())
if n==1: print(2);sys.exit()

l=[list(map(int,input().split())) for _ in range(n)]
l=sorted(l)
x=[l[i][0] for i in range(n)]
d=[l[i][1] for i in range(n)]
dp=[[0,0] for _ in range(n)]
dp[n-1]=[1,1]

for i in range(n-2,-1,-1):
    dp[i][0]=dp[i+1][0]+dp[i+1][1]
    if x[i]+d[i]<=x[i+1]: dp[i][1]=dp[i][0]
    elif x[i]+d[i]<=x[i+1]+d[i+1]: dp[i][1]=dp[i+1][1]
    else:
        p=bisect.bisect_right(x,x[i]+d[i])-1
        dp[i][1]=min(dp[p][1],dp[i+1][1])
    dp[i]=[x%mod for x in dp[i]]

print(sum(dp[0])%mod)

### FIXED CODE ###

s=input()
print("Yes" if "A" in s and "B" in s else "No")
n = int(input())
xyd = [list(input().split()) for i in range(n)]
xmax,ymax = [-10**18,-10**18,-10**18],[-10**18,-10**18,-10**18]
xmin,ymin = [10**18,10**18,10**18],[10**18,10**18,10**18]
#xmax: max(x1-t,x2,x3+t)
#xmin: min(x1+t,x2,x3-t)
#ymax: max(y1-t,y2,y3+t)
#ymin: min(y1+t,y2,y3-t)
def chp(ls,a,flg1,i):
  if flg1:
    ls[i] = max(ls[i],a)
  else:
    ls[i] = min(ls[i],a)
def area(t):
  x = max(xmax[0]-t,xmax[1],xmax[2]+t)-min(xmin[0]+t,xmin[1],xmin[2]-t)
  y = max(ymax[0]-t,ymax[1],ymax[2]+t)-min(ymin[0]+t,ymin[1],ymin[2]-t)
  return x*y
for x,y,d in xyd:
  x,y = int(x),int(y)
  if d in ("L","R"):
    chp(ymax,y,1,1)
    chp(ymin,y,0,1)
    if d == "R":
      chp(xmin,x,0,0)
      chp(xmax,x,1,2)
    if d == "L":
      chp(xmin,x,0,2)
      chp(xmax,x,1,0)
  elif d in ("U","D"):
    chp(xmax,x,1,1)
    chp(xmin,x,0,1)
    if d == "U":
      chp(ymax,y,1,2)
      chp(ymin,y,0,0)
    if d == "D":
      chp(ymin,y,0,2)
      chp(ymax,y,1,0)

event = [0]
for ls in xmax,ymax:
  event.append(ls[0]-ls[1])
  event.append((ls[0]-ls[2])/2)
  event.append(ls[1]-ls[2])
for ls in xmin,ymin:
  event.append(ls[1]-ls[0])
  event.append((ls[2]-ls[0])/2)
  event.append(ls[2]-ls[1])
ans = 10**20

for i in event:
  if i>=0:
    for j in range(-10,10):
      if i+j*0.5 >= 0:
        ans = min(ans,area(i+j*0.5))
l = 0
r = 10**9
for _ in range(10000):
  ml = l*2/3+r*1/3
  mr = l*1/3+r*2/3
  if area(ml) <= area(mr):
    r = mr
  else:
    l = ml
print(min(ans,area(ml)))

### FIXED CODE ###

a,b=map(int,input().split())
if a>=b:
  print(10)
else:
  print(0)
from collections import Counter
h, w, m = map(int, input().split())
targets_map = [[0]*w for _ in range(h)]
targets_count_tate = [0]*w
targets_count_yoko = [0]*h
for _ in range(m):
    y, x = map(int, input().split())
    y -= 1
    x -= 1
    targets_count_tate[x] += 1
    targets_count_yoko[y] += 1
    targets_map[y][x] = 1


max_line = max(targets_count_yoko)
max_row = max(targets_count_tate)
yoko_idx = []
tate_idx = []
for i in range(h):
    if targets_count_yoko[i] == max_line:
        yoko_idx.append(i)
for i in range(w):
    if targets_count_tate[i] == max_row:
        tate_idx.append(i)

ans = max_line + max_row - 1
flag = True
for y in yoko_idx:
    for x in tate_idx:
        if targets_map[y][x] != 1:
            flag = False
            break
    else:
        continue
    break

if flag:
    print(ans)
else:
    print(ans+1)







### FIXED CODE ###

from collections import defaultdict
h, w, m = map(int, input().split())
targets = defaultdict(int)
targets_count_yoko = defaultdict(int)
targets_count_tate = defaultdict(int)
for _ in range(m):
    y, x = map(int, input().split())
    y -= 1
    x -= 1
    targets_count_yoko[x] += 1
    targets_count_tate[y] += 1
    targets[(y, x)] = -1

max_row = max(targets_count_yoko.values())
max_line = max(targets_count_tate.values())
y_idx = defaultdict(bool)
x_idx = defaultdict(bool)
max_count_x = 0
max_count_y = 0
for i in range(w):
    if targets_count_yoko[i] == max_row:
        x_idx[i] = True
        max_count_x += 1
for i in range(h):
    if targets_count_tate[i] == max_line:
        y_idx[i] = True
        max_count_y += 1


ans = max_line + max_row
kumi = max_count_x*max_count_y
for key_y, key_x in targets.keys():
    if y_idx[key_y] and x_idx[key_x]:
        kumi -= 1
    if kumi == 0:
        break

if kumi == 0:
    print(ans-1)
else:
    print(ans)
a,b=map(int,input())
c=[a,b,a-1,b-1];c.sort()
print(sum(c[-2:]))

### FIXED CODE ###

a,b=map(int,input().split());c=[a,b,a-1,b-1];c.sort();print(sum(c[-2:]))
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

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

n = int(input())
a = [int(input()) for _ in range(n)]

b = lcm(a[0],a[1])
for i in range(2,n):
    b = lcm(b,a[i])
print(int(b))

### FIXED CODE ###

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

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

n = int(input())
a = [int(input()) for _ in range(n)]

if n == 1:
    print(a[0])
    exit()

for i in range(n-1):
    if i == 0:
        b = lcm(a[i],a[i+1])
    else:
        b = lcm(b,a[i+1])
print(b)
#値の入力
A1 = int(input())
A2 = int(input())
A3 = int(input())

#値が範囲内か
if(1 > A1 or A1 > 13):
    print("もう一度入力して下さい")
    A1 = int(input("A1:"))
if(1 >A2 or A2 > 13):
    print("もう一度入力して下さい")
    A2 = int(input("A2:"))
if(1 > A3 or A3 > 13):
    print("もう一度入力して下さい")
    A3 = int(input("A3:"))

#判定
if(A1+ A2+ A3 >= 22):
    print("bust")
else:
    print("win")


### FIXED CODE ###

#値の入力
A1, A2, A3 = map(int, input(). split()) 

#値が範囲内か
if 1 > A1 or A1 > 13:
    print("もう一度入力して下さい")
    A1 = int(input("A1:"))
if 1 >A2 or A2 > 13:
    print("もう一度入力して下さい")
    A2 = int(input("A2:"))
if 1 > A3 or A3 > 13:
    print("もう一度入力して下さい")
    A3 = int(input("A3:"))

#判定
if(A1+ A2+ A3 >= 22):
    print("bust")
else:
    print("win")
a, b, k = map(int, input().split())
if a >= k:
    a -= k
else:
    b = max(0,k - a)
    a = 0
print(a, b)

### FIXED CODE ###

s, t = input().split()
print(t,s,sep='')
import math
from collections import defaultdict
N = int(input())
d = defaultdict(int)
def sieve_of_erastosthenes(num):
    input_list = [False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(num)]
    input_list[0] = input_list[1] = False
    input_list[2] = input_list[3] = input_list[5] = True
    sqrt = math.sqrt(num)

    for serial in range(3, num, 2):

        if serial >= sqrt:
            return input_list

        for s in range(serial ** 2, num, serial):
            input_list[s] = False
l = sieve_of_erastosthenes(N)
cnt = 0
while N != 1 and cnt<len(l):

    while l[cnt] and N%cnt == 0:
        d[cnt] += 1
        N //=cnt
    cnt += 1
ans = 0
for i in d.values():
    tmp = 1
    while i - tmp >= 0:
        i -= tmp
        tmp += 1
        ans += 1
print(ans)

### FIXED CODE ###

import copy
from collections import defaultdict

N = int(input())
tmp = copy.copy(N)
d = defaultdict(int)
if N == 1:
    print(0)
    exit()
for i in range(2, int(N ** 0.5) + 3):
    while N % i == 0:
        N //= i
        d[i] += 1
if N > 1:
    d[N] += 1
ans = 0
for i in d.values():
    tmp = 1
    while i - tmp >= 0:
        i -= tmp
        tmp += 1
        ans += 1
print(ans)
#dp
n,m  = map(int,input().split())
ln = [-1 for i in range(n +1)]
mod_1 = 10**9 + 7
for i in range(m):
    ln[int(input())] = 0

for i in range(n+1):
    if ln[i] ==0
        pass
    elif i == 0:
        ln[i] = 1
    elif i == 1:
        ln[i] = 1
    else:
        ln.append((ln[-1] + ln[-2]) % mod_1)
print(ln[-1])


### FIXED CODE ###

#dp
n,m  = map(int,input().split())
ln = [-1 for i in range(n +1)]
mod_1 = 10**9 + 7
for i in range(m):
    ln[int(input())] = 0
#print(ln)
for i in range(n+1):
    if ln[i] ==0:
        pass
    elif i == 0:
        ln[i] = 1
    elif i == 1:
        ln[i] = 1
    else:
        ln[i] = (ln[i-1] + ln[i-2]) % mod_1
#print(ln)
print(ln[-1])
n. m = map(int, input().split())
print((n-1)*(m-1))

### FIXED CODE ###

n, m = map(int, input().split())
print((n-1)*(m-1))
N, L = (int(i) for i in input().split())
C = 0
S = 0

if L > 0:
	for i in range(N):
		if i > 0:
			S += L + i
elif L+N-1 < 0:
	for i in range(N):
		if i < N-1:
			S += L + i
else:
	for i in range(N):
		S += L + i

print(S)



### FIXED CODE ###

S = input()
C = 0
for i in range(3):
	if S[i] == S[i+1]:
		C = 1

if C == 1:
	print('Bad')
else:
	print('Good')
input = input()
hour = input / 3600
minute = hour / 60
second = minute / 60
print"%1:%2:%3" % (hour,minute,second)

### FIXED CODE ###

input = int(input())
if 0 <= input < 86400:
    hour = input / 3600
    minute = (input / 60) % 60
    second = input % 60
    print("%d:%d:%d" % (hour,minute,second))
n, k = map(int, input().split())
p = list(map(int, input().split()))

for i in range(n-2):
  sump0=0
  sump=p[i]+p[i+1]+p[i+2]
  if sump>smp0:
    sum0=sump
    
print(sum0/2+k/2)

### FIXED CODE ###

import itertools
 
n, k = map(int, input().split())
p = list(map(int, input().split()))
acc = [0] + list(itertools.accumulate([(x+1)/2 for x in p])) # 累積和を計算
 
ans = max(acc[i]-acc[i-k] for i in range(k, n+1)) # k番目からn番目まで計算
print(ans)
N,W=map(int,input().split())

items=[]

for i in range(N):
    items.append(list(map(int,input().split())))
    
dp = [[0 for i in range(100)] for j in range(100)]

for i in range(N):
    dp[i][0]=0
    
for i in range(N):
    for w in range(W+1):
        if w>=items[i][1]:
            dp[i+1][w]=max(dp[i][w-items[i][1]]+items[i][0],dp[i][w])
        else:
            dp[i+1][w]=dp[i][w]
        


print(dp[N][W])



### FIXED CODE ###

N,W=map(int,input().split())

items=[]

for i in range(N):
    items.append(list(map(int,input().split())))
    
dp = [[0 for i in range(10001)] for j in range(110)]

for i in range(N):
    dp[i][0]=0
    
for i in range(N):
    for w in range(W+1):
        if w>=items[i][1]:
            dp[i+1][w]=max(dp[i][w-items[i][1]]+items[i][0],dp[i][w])
        else:
            dp[i+1][w]=dp[i][w]
        


print(dp[N][W])
n,x=map(int,input().split())
l=list(map(int,input().split()))

ans=0
d=0

for i in range(n):
    d+=l[i]
    ans+=1
    if(d>x):
        break

if(i=n-1):
    ans-=1
print(ans)


### FIXED CODE ###

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

ans=0
d=0

for i in range(n):
    d+=l[i]
    if(d<=x):
        ans+=1
        
print(ans+1)
a, b, c = map(int, input(),split())
print(a * b // 2)

### FIXED CODE ###

a, b, c = map(int, input().split())
print(a * b // 2)
import math
n , a , b  = map(int, input().split())
if a >= n : exit(print(n))
if a == 0: exit(print(0))
ans = n//(a+b)
#print("ans",ans)
print(ans*a+(n-ans*a-ans*b))


### FIXED CODE ###

s = list(input())
if len(set(s)) == 1:
    print("No")
else:
    print("Yes")
import math

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

q = a*b*b/2/x

print(math.degrees(math.atan(q))

### FIXED CODE ###

import math

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

q = a*b*b/2/x
w = (2*b-2*x/a**2)/a

if 2*x/a/b <= a:
  print(math.degrees(math.atan(q)))
else:
  print(math.degrees(math.atan(w)))
n = int(input())
s = input()

n /= 2
if s[:n] == s[n:]:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

n = int(input())
s = input()

n //= 2
if s[:n] == s[n:]:
  print("Yes")
else:
  print("No")
N = int(input())
W = []
flag = "Yes"
last_chara = ''
for i in range(N):
  now_W = input()
  www = list(now_W)
  if i != 0:
    if www[0] != last_chara:
      flag = "No"
      break
  if now_W in W:
    flag = "No"
    break
  W.append(now_W)
  last_chara = www[-1]
print(flag)

### FIXED CODE ###

A, B = list(map(int, input().split()))
if A * B % 2 == 0:
  print("No")
else:
  print("Yes")
n, k = map(int, input().split())
s = input()

print(s[:k] + s[k].lower() + s[k+1:])

### FIXED CODE ###

n, k = map(int, input().split())
s = input()

print(s[:k-1] + s[k-1].lower() + s[k:])
from math import pi
print('{.5f} {.5f}'.format(r*r*pi,r*2*pi)

### FIXED CODE ###

from math import pi
r = float(input())
print('{:.5f} {:.5f}'.format(r*r*pi,r*2*pi))
n=int(input())
a=[int(input()) for _ in range(n)]
ans=a[0]
import math
for i in range(1, n):
    ans = ans * a[i] // math.gcd(ans, a[i])
print(ans)

### FIXED CODE ###

n=int(input())
a=[int(input()) for _ in range(n)]
ans=a[0]
from fractions import gcd
for i in range(1, n):
    ans = ans * a[i] // gcd(ans, a[i])
print(ans)
a, b, c = (int(i) for i in input().split())
if a + b >= c:
    print("Yes")
else:
    print("No")5

### FIXED CODE ###

a, b, c = (int(i) for i in input().split())
if a + b >= c:
    print("Yes")
else:
    print("No")
while True:
  x,y = map(int,raw_input().split())
  y = input()
  if x == y == 0:
    break
  print min(x,y), max(x,y)

### FIXED CODE ###

while True:
  x,y = map(int,raw_input().split())
  if x == y == 0:
    break
  print min(x,y), max(x,y)
K = int(input())
aaa = 1
ans_array = []

def sunuke(n):
    re = 0
    tmp = n
    while n:
        re += n % 10
        n = n//10
    re = tmp/re
    print(re)

def print_sunuke():
    global aaa
    num = aaa % 10
    if num == 0:
        aaa += 1
        print_sunuke()
        return
    nine = aaa // 10
    ans = str(num) + "9" * nine
    aaa += 1
    ans_array.append(int(ans))




for i in range(10000):

    print_sunuke()

ans_array.append(1899)
ans_array.append(2899)
ans_array.append(3899)
ans_array.append(4899)
ans_array.append(5899)
ans_array.append(6899)
ans_array.append(7899)
ans_array.append(8899)
ans_array.append(9899)
ans_array.append(18999)
ans_array.append(28999)
ans_array.append(38999)
ans_array.append(48999)
ans_array.append(58999)
ans_array.append(68999)
ans_array.append(78999)
ans_array.append(88999)
ans_array.append(98999)
ans_array.append(189999)
ans_array.append(289999)
ans_array.append(389999)
ans_array.append(489999)
ans_array.append(589999)
ans_array.append(689999)
ans_array.append(789999)
ans_array.append(889999)
ans_array.append(989999)
ans_array.append(1899999)
ans_array.append(2899999)
ans_array.append(3899999)
ans_array.append(4899999)
ans_array.append(5899999)
ans_array.append(6899999)
ans_array.append(7899999)
ans_array.append(8899999)
ans_array.append(9899999)

ans_array.append(18999999)
ans_array.append(28999999)
ans_array.append(38999999)
ans_array.append(48999999)
ans_array.append(58999999)
ans_array.append(68999999)
ans_array.append(78999999)
ans_array.append(88999999)
ans_array.append(98999999)

ans_array.append(189999999)
ans_array.append(289999999)
ans_array.append(389999999)
ans_array.append(489999999)
ans_array.append(589999999)
ans_array.append(689999999)
ans_array.append(789999999)
ans_array.append(889999999)
ans_array.append(989999999)
ans_array.append(1899999999)
ans_array.append(2899999999)
ans_array.append(3899999999)
ans_array.append(4899999999)
ans_array.append(5899999999)
ans_array.append(6899999999)
ans_array.append(7899999999)
ans_array.append(8899999999)
ans_array.append(9899999999)

ans_array.append(18999999999)
ans_array.append(28999999999)
ans_array.append(38999999999)
ans_array.append(48999999999)
ans_array.append(58999999999)
ans_array.append(68999999999)
ans_array.append(78999999999)
ans_array.append(88999999999)
ans_array.append(98999999999)


ans_array.sort()

for i in range(K):
    print(ans_array[i])





### FIXED CODE ###

# n = int(input())
N, K = map(int, input().split())
A = list(map(int, input().split()))
# d = [list(map(int, input().split())) for _ in range(n)]
# s = input()

if (N-1)%(K-1):
    ans =(N-1)//(K-1)+1
else:
    ans = (N-1) // (K - 1)


print(ans)


# K = int(input())