Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

x = int(input())

while True:
    if x % 2 == 0:
        x += 1
        continue
    i = 1
    while i * i <= x:
        if x % i == 0:
            break
        i += 1
    else:
        print(x)
        exit()
    x += 1


### FIXED CODE ###

x = int(input())
if x == 2:
    print(2)
    exit()
i = 3
f = False
while True:
    if x % 2 == 0:
        x += 1
        continue
    while i * i <= x:
        if x % i == 0:
            i += 2
            f = True
            break
        else:
            i += 2
    if not f:
        print(x)
        exit()
    x += 1
    i = 3
    f = False
### BUGGY CODE ###

import copy
A, B, C, K = map(int, input().split())
maxL = 10 ** 18
L = [A, B, C]
for i in range(K):
    newL = [L[1] + L[2], L[0] + L[2], L[0] + L[1]]
    L = copy.copy(newL)

ans = L[0] - L[1]
if ans >= maxL:
    print("Unfair")
else:
    print(ans)

### FIXED CODE ###

A, B, C, K = map(int, input().split())
maxL = 10 ** 18
L = [A, B, C]
ans = A - B
if ans >= maxL:
    print("Unfair")
else:
    if K % 2 == 0:
        print(ans)
    else:
        print(ans * (-1))
### BUGGY CODE ###

import numpy as np
from operator import mul
from functools import reduce

def cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

N,M=map(int,list(input().split(" ")))
mod=10**9+7
def factor(M):
    i=2
    lis=[]
    if M%i==0:
        k=1
        M//=2
        while M%2==0:
            k+=1
            M//=2
        lis.append([2,k])
    i+=1
    while M!=1:
        if M%i==0:
            k=1
            M//=i
            while M%i==0:
                k+=1
                M//=i
            lis.append([i,k])
        i+=2
    return lis

fac=np.array(factor(M))
ans=1
for i in range(len(fac)):
    ans*=cmb(N+fac[i][1]-1,N-1)
print(ans%mod)

### FIXED CODE ###

import numpy as np
from operator import mul
from functools import reduce

def cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

N,M=map(int,list(input().split(" ")))
mod=10**9+7
def factor(n):
    fct = []  
    b, e = 2, 0 
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct

fac=np.array(factor(M))
ans=1
for i in range(len(fac)):
    ans*=cmb(N+fac[i][1]-1,N-1)
print(ans%mod)
### BUGGY CODE ###

import math
s = input()[::-1] # 入力文字列を逆順でsに格納
n = len(s)
# taro = [0]*n
s_ = [0]*n
counts = [0]*2019
counts[0]=1
b = 1
num = 0
for i in range(n):
    s_[i] = int(s[i])*b +num
    num += int(s[i])*b
    num %=2019
    b *=10
    b %2019
    counts[num]+=1

# for i in range(n):
#     a = s_[i]%2019
#     taro[i]=a
# print(taro)
# counts = [0]*2019
# for i in range(n):
#     counts[taro[i]]+=1
def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
# print(counts)
ans = 0
for j in counts:
    if j>=2:
        ans +=combinations_count(j, 2)


print(ans)

### FIXED CODE ###

s = input()[::-1] # 入力文字列を逆順でsに格納

counts = [0] * 2019
counts[0] = 1

num, d = 0, 1

for char in s:
    num += int(char) * d
    num %= 2019
    d *= 10
    d %= 2019
    counts[num] += 1

ans = 0
for cnt in counts:
    ans += cnt * (cnt - 1) // 2

print(ans) # 答えの出力
### BUGGY CODE ###

# coding: utf-8
# Your code here!
import bisect
import sys
input=sys.stdin.readline
n=int(input())
d=list(map(int,input().split()))
m=int(input())
t=list(map(int,input().split()))
ans='NO'
d.sort()
for i in range(m):
    if d[bisect.bisect_right(d,t[i])-1]==t[i]:
        d.remove(d[bisect.bisect_right(d,t[i])-1])
        if i==m-1:
            ans='YES'
    else:
        break
print(ans)


### FIXED CODE ###

from collections import Counter
n=int(input())
d=list(map(int,input().split()))
m=int(input())
t=list(map(int,input().split()))

d_c=Counter(d)
t_c=Counter(t)
for i in t_c.keys():
    if t_c[i]>d_c[i]:
        print('NO')
        exit()
print('YES')
### BUGGY CODE ###

n,m = map(int,input().split())
l = []
for i in range(m):
    a,b = map(int,input().split())
    c = 0
    for j in map(int,input().split()):
        c += (1<<(j-1))
    l.append((c,a))

dp = dict()
tmp = [(0,0)]
while tmp != []:
    tmp2 = []
    for i in tmp:
        for j in l:
            if j[0] | i[0] != i[0]:
                ctmp = (j[0] | i[0] ,i[1] + j[1])
                if dp.get(ctmp[0],-1) == -1:
                    dp[ctmp[0]] = ctmp[1]
                    if ctmp[0] != 2**n - 1:
                        tmp2.append(ctmp)
                else:
                    if dp[ctmp[0]] > ctmp[1]:
                        dp[ctmp[0]] = ctmp[1]
                    if ctmp[0] != 2**n - 1:
                        tmp2.append(ctmp)
    tmp = tmp2

print(dp.get(2**n-1,-1))


### FIXED CODE ###

n,m = map(int,input().split())
l = []
for i in range(m):
    a,b = map(int,input().split())
    c = 0
    for j in map(int,input().split()):
        c += (1<<(j-1))
    l.append((c,a))
dp = {0:0}
for i in l:
    items = list(dp.items())
    for j in items:
        ij = (i[0] | j[0], i[1] + j[1])
        if not dp.get(ij[0]):
            dp[ij[0]] = ij[1]
        else:
            if dp[ij[0]] > ij[1]:
                dp[ij[0]] = ij[1]

print(dp.get(2**n-1,-1))
### BUGGY CODE ###

n = int(input())
l = list(map(int,input().split()))
count = 0
l.sort()
print(l)
'''
def binary_search(key,l,n):
    key_number = int((n-1)//2)
    L = 0
    R = n-1
    while True:
        if l[key_number] < key:
            L = key_number
            key_number = (L+R)//2
        else:
            R = key_number
            key_number = (L+R)//2
        if key == l[key_number]:
            return key_number
        if (R-L) == 1:
            return L+1
'''
def binary_search(key,l,n):
    L = 0
    R = n-1
    while L < R:
        key_number = int((n-1)//2)
        if l[key_number] < key:
            L = key_number + 1
        else:
            R = key_number
    return key_number

for i in range(n-2):
    for j in range(i+1,n-1):
        double_count = 0
        a = l[i]
        b = l[j]
        key_numberR = binary_search(a+b,l,n)
        key_numberL = binary_search(b-a,l,n)
        print("{} <c< {} b-a = {} a+b = {}".format(key_numberL,key_numberR,b-a,a+b))

        if key_numberL<= i and i<=key_numberR:
            double_count += 1
        if key_numberL<= j and j <= key_numberR:
            double_count += 1

        #print('i={} j={} key_numberL={} key_numberR={} count={}'.format(i,j,key_numberL,key_numberR,-key_numberL-double_count))
        count += key_numberR-key_numberL-double_count
print(count)

### FIXED CODE ###

import bisect
n = int(input())
l = list(map(int,input().split()))
count = 0
l.sort()

def binary_search(key,l,n):
    key_number = int((n-1)//2)
    L = 0
    R = n-1
    while True:
        if l[key_number] < key:
            L = key_number
            key_number = (L+R)//2
        else:
            R = key_number
            key_number = (L+R)//2

        if key == l[key_number]:
            return key_number
        if (R-L) == 1:
            return L+1

def binary_search(key,l,n):
    L = 0
    R = n-1
    while L < R:
        key_number = int((n-1)//2)
        if l[key_number] < key:
            L = key_number + 1
        else:
            R = key_number
    return key_number

ans = 0
#print(binary_search(7+8,l,n))

for i in range(n-2):
    for j in range(i+1,n-1):
        a = l[i]
        b = l[j]

        ans += bisect.bisect_left(l,a+b)- j -1

        #print("{} <c< {} b-a = {} a+b = {}".format(key_numberL,key_numberR,b-a,a+b))

        #print('i={} j={} key_numberL={} key_numberR={} count={}'.format(i,j,key_numberL,key_numberR,-key_numberL-double_count))
        #count += key_numberR-key_numberL-double_count
print(ans)
### BUGGY CODE ###

N = int(input())
A = list(map(int, input().split()))

ans = 1

for a in A:
    ans *= a
    if a == 0:
        print(0)
        break

else:
    if ans > 1000000000000000000:
        print(-1)
    else:
        print(ans)


### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))

ans = 1

if 0 in A:
    print(0)
else:
    for a in A:
        ans *= a
        if ans > 1000000000000000000:
            print(-1)
            break
    else:
        print(ans)
### BUGGY CODE ###

H, A = map(int, input().split())

x = 0
while True:
  if H < 0:
    break
  else:
    x += 1
print(x)

### FIXED CODE ###

H, A = map(int, input().split())

x = 0
while True:
  if H <= 0:
    break
  if H > 0:
    H -= A
    x += 1
print(x)
### BUGGY CODE ###

import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

#　DFSで解いてみる

h, w = LI()

b = [[0 for i in range(w)] for j in range(h)]
b[0][0] = 0

ans = 0

def DFS(x, y):
    # print(x,y)
    if not(0 <= x < w) or not(0 <= y < h) or (b[y][x]==1):
        return
    
    b[y][x] = 1
    global ans
    ans += 1

    # for l in b:
    #     print(l)
    # print("右下探索")
    DFS(x+1,y+1)
    
    # print("右上探索") 
    DFS(x+1,y-1) 
    
    # print("左上探索") 
    DFS(x-1,y-1)

    # print("左下探索") 
    DFS(x-1,y+1) 

DFS(0, 0)
print(ans)

### FIXED CODE ###

import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

h, w = LI()

if h == 1 or w == 1:
    print(1)

else:    
    if (h * w) % 2 == 0:
        print(int(h * w / 2))
    else:
        print(int(h * w / 2 + 1))
### BUGGY CODE ###

a,b,c=map(int,input().split())
ans=0
while 1:
    if b>0:
        a-=b
        ans+=1
    else:
        break
print(ans*c)

### FIXED CODE ###

n,x,t=map(int,input().split())
if n%x==0:
    print(int(n/x*t))
else:
    print(int(n//x+1)*t)
### BUGGY CODE ###

N = int(input())
ans = 100000
for i in range(1, 10 ** 8):
    if N % i == 0:
        ans = min(ans, max(len(str(i)), len(str(N // i))))

print(ans)


### FIXED CODE ###

N = int(input())
ans = 100000
for i in range(1, 10 ** 5):
    if N % i == 0:
        ans = min(ans, max(len(str(i)), len(str(N // i))))

print(ans)
### BUGGY CODE ###

N = int(input())
print(sum(A*B + C == N for A in range(1,N) for B in range(1,N) for C in range(1,N)))

### FIXED CODE ###

import math
N = int(input())
A = [0]*(N)
for i in range(0,N):
    A[i] = math.floor((N-1)/(i+1))
print(sum(A))
### BUGGY CODE ###

n,k = map(int,input().split())
h = list(map(int,input().split()))
dp=[1000000000]*n
dp[0]=0
for i in range(1,n):
  for j in range(k):
    if i > j:
      dp[i] = min(dp[i],dp[i-j-1]+abs(h[i]-h[i-j-1]))
print(dp[-1])

### FIXED CODE ###

n,k = map(int,input().split())
h = list(map(int,input().split()))
dp=[100000000000000000]*n
dp[0]=0
for i in range(1,n):
  for j in range(k):
    if i > j:
      dp[i] = min(dp[i],dp[i-j-1]+abs(h[i]-h[i-j-1]))
print(dp[-1])
### BUGGY CODE ###

import sys

# import numpy as np

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

INF = 10 ** 18


def main():
    N, W = map(int, input().split())
    w = []
    v = []
    for i in range(N):
        weight, value = map(int, input().split())
        w.append(weight)
        v.append(value)

    """    
    dp[ i ] : 価値 i における重さの最小値
    　
    品物一つ w,v を見ていくたびに、
    dp[ i ] = (その品物を使うパターン) or (その品物を使わないパターン)
    = min( dp[i -v] + w , dp[ i ] ) 
    を更新していけばよい。
    """

    dp = [0] + [INF] * 10 ** 5

    for i in range(N):
        for j in range(10 ** 5, v[i] - 1, -1):
            dp[j] = min(dp[j - v[i]] + w[i], dp[j])

    # print(dp[:30])

    ans = 0

    for i, j in enumerate(dp):
        if j <= W:
            ans = i
    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys

# import numpy as np

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

INF = 10 ** 18


def main():
    N, W = map(int, input().split())
    w = []
    v = []
    for i in range(N):
        weight, value = map(int, input().split())
        w.append(weight)
        v.append(value)

    """    
    dp[ i ] : 価値 i における重さの最小値
    　
    品物一つ w,v を見ていくたびに、
    dp[ i ] = (その品物を使うパターン) or (その品物を使わないパターン)
    = min( dp[i -v] + w , dp[ i ] ) 
    を更新していけばよい。
    """

    dp = [0] + [INF] * 10 ** 5

    for i in range(N):
        for j in range(10 ** 5, v[i] - 1, -1):
            dp[j] = min(dp[j - v[i]] + w[i], dp[j])

    # print(dp[:30])

    ans = 0

    for i, j in enumerate(dp):
        if j <= W:
            ans = i
    print(ans)


if __name__ == "__main__":
    main()
### BUGGY CODE ###

n, k = map(int, input().split())
h = [0] + list(map(int, input().split()))
cost = {1: 0, 2: abs(h[2] - h[1])}
for i in range(1, n):
    for di in range(1, k + 1):
        if i + di > n: break
        if i + di in cost:
            cost[i + di] = min(cost[i + di], cost[i] + abs(h[i + di] - h[i]))
        else:
            cost[i + di] = cost[i] + abs(h[i + di] - h[i])
print(cost[n])


### FIXED CODE ###

n, k = map(int, input().split())
k = min(n - 1, k)
h = list(map(int, input().split()))
cost = [0 for _ in range(n)]
for i, hi in enumerate(h):
    if i == 0: continue
    st = i - k if i > k else 0
    cost[i] = min([ck + abs(hi - hk) for ck, hk in zip(cost[st:i], h[st:i])])
print(cost[-1])
### BUGGY CODE ###

# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

n,k,*a = map(int,read().split())

a = [i for i in a if i<k]
n = len(a)


mask = (1<<k)-1

dpl = [1]
dp = 1
for i in a:
    dp |= dp<<i
    dp &= mask
    dpl.append(dp)

dpr = [1]
dp = 1
for i in a[::-1]:
    dp |= dp<<i
    dp &= mask
    dpr.append(dp)


ans = 0
for i in range(n):
    l = dpl[i]
    r = dpr[n-1-i]
    #print(bin(l),bin(r))
    mask = ((1<<a[i])-1)<<(k-a[i])
    #print(bin(mask))
    for j in range(k):
        if l>>j&1 and r&mask:
            break
        mask >>= 1
    else:
        #print(i)
        ans += 1


print(ans)



### FIXED CODE ###

# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

n,k,*a = map(int,read().split())

a = [i for i in a if i<k]
n = len(a)

a.sort(reverse=True)

K = 2*k+1
mask = (1<<K)-1

dpl = [1]
dp = 1
for i in a:
    dp |= (dp<<i)&mask
    dpl.append(dp)

#print(dpl)
for i in range(n):
    x = dpl[n-1-i]<<a[n-1-i]
    mask = ((1<<a[n-1-i])-1)<<(k)
    #print(bin(x)[::-1])
    #print(bin(mask)[::-1])
    if x&mask:
        print(i)
        break
else: print(n)
### BUGGY CODE ###

import sys

def main():
    input = sys.stdin.readline
    N = int(input())
    A = [int(input()) for _ in range(N)]
    MOD = 998244353

    S = sum(A)
    dp = [[0 for _ in range(S+1)] for _ in range(N)]
    a = A[0]
    dp[0][a] = 1
    dp[0][0] = 2
    for i in range(1, N):
        a += A[i]
        for j in range(a+1):
            dp[i][j] = dp[i-1][j] * 2

            if j >= A[i]:
                dp[i][j] += dp[i-1][j-A[i]]

            dp[i][j] %= MOD

    dp2 = [[0 for _ in range(S+1)] for _ in range(N)]
    a = A[0]
    dp2[0][a] = 1
    dp2[0][0] = 1
    for i in range(1, N):
        a += A[i]
        for j in range(a+1):
            dp2[i][j] = dp2[i-1][j]

            if j >= A[i]:
                dp2[i][j] += dp2[i-1][j-A[i]]

            dp2[i][j] %= MOD

    ng = 0
    if S % 2 == 1:
        for i in range(S//2 + 1, S+1):
            ng += dp[N-1][i]

        ng = (ng * 3) % MOD

    else:
        for i in range(S//2, S+1):
            ng += dp[N-1][i]

        ng = (ng * 3 - dp2[N-1][S//2] * 3) % MOD

    ans = (pow(3, N, MOD) - ng) % MOD

    
    return ans


if __name__ == '__main__':
    print(main())


### FIXED CODE ###

import sys
import numpy as np

def main():
    input = sys.stdin.readline
    N = int(input())
    A = [int(input()) for _ in range(N)]
    MOD = 998244353

    S = sum(A)
    a = A[0]
    # dp0[i][j]: DP table
    #            the number of combinations that the one side length is j 
    #            until using the i-th A[i].
    dp0 = np.zeros((N, S+1), dtype=np.int64)
    dp0[0, a] = 1
    dp0[0, 0] = 2

    # dp1[i][j]: DP table
    #            the number of one side length is j and the other one is 0
    #            until using the i-th A{i].
    dp1 = np.zeros((N, S+1), dtype=np.int64)
    dp1[0, a] = 1
    dp1[0, 0] = 1
    for i in range(1, N):
        a = A[i]

        dp0[i, :] += dp0[i-1, :] * 2
        dp0[i, a:] += dp0[i-1, :-a]
        dp0[i, :] %= MOD

        dp1[i, :] += dp1[i-1, :]
        dp1[i, a:] += dp1[i-1, :-a]
        dp1[i, :] %= MOD


    ng = 0
    if S % 2 == 1:
        ng = np.sum(dp0[N-1, S//2 + 1:])
        ng = (ng * 3) % MOD

    else:
        ng = np.sum(dp0[N-1, S//2:])
        ng = (ng * 3 - dp1[N-1][S//2] * 3) % MOD

    ans = (pow(3, N, MOD) - ng) % MOD
    return ans


if __name__ == '__main__':
    print(main())
### BUGGY CODE ###

X,Y=map(int,input().split())

mod=10**9+7
def nCr(n, r, mod):
    r = min(r, n-r)
    numer = denom = 1
    for i in range(1, r+1):
        numer = numer * (n+1-i) % mod
        denom = denom * i % mod
    return numer * pow(denom, mod-2, mod) % mod

if (X+Y)%3 != 0:
      print(0)
      exit()
 
n,x,y=0,X,Y
while x != y*2:
      x-=1
      y-=2
      n+=1

m=((X+Y)//3)-n

if n<0 or m<0:
    print(0)
    exit()

ans = nCr(n+m,n,mod)
print(ans)


### FIXED CODE ###

X,Y=map(int,input().split())

mod=10**9+7
def nCr(n, r, mod):
    r = min(r, n-r)
    numer = denom = 1
    for i in range(1, r+1):
        numer = numer * (n+1-i) % mod
        denom = denom * i % mod
    return numer * pow(denom, mod-2, mod) % mod

if (X+Y)%3 != 0:
      print(0)
      exit()
 
n=((2*X)-Y)//3

m=((X+Y)//3)-n

if n<0 or m<0:
    print(0)
    exit()

ans = nCr(n+m,n,mod)
print(ans)
### BUGGY CODE ###

from statistics import median
from time import time

t = time()

N, K = [int(x) for x in input().split()]
line_in_dice = list([int(x) for x in input().split()])

result = [0] * (N + K)

result[0] = line_in_dice[0]
result[K] -= line_in_dice[0]

max_point = 0
max_value = 0

for i in range(1, N):
    result[i] += (result[i - 1] + line_in_dice[i])
    result[i + K] -= line_in_dice[i]

    if result[i] > max_value:
        max_point = i
        max_value = result[i]

print(sum([median(range(1, x+1))
           for x in line_in_dice[max_point+1-K:max_point+1]]))


### FIXED CODE ###

from statistics import median
from time import time

t = time()

N, K = [int(x) for x in input().split()]
line_in_dice = list([int(x) for x in input().split()])

result = [0] * (N + K)

result[0] = line_in_dice[0]
result[K] -= line_in_dice[0]

max_point = 0
max_value = 0

for i in range(1, N):
    result[i] += (result[i - 1] + line_in_dice[i])
    result[i + K] -= line_in_dice[i]

    if result[i] > max_value:
        max_point = i
        max_value = result[i]


def create_median(x):
    if x % 2 == 1:
        return (1 + x) // 2
    else:
        return ((x // 2) + (x // 2 + 1)) / 2


print(sum(create_median(x)
          for x in line_in_dice[max_point - K + 1: max_point+1]))
### BUGGY CODE ###

s = input()
q = int(input())

rev = 0
for i in range(q):
	g = input()
	if len(g) == 1:
		rev += 1
	else:
		f = int(g[2])
		c = g[4]
		if f == 2:
			if rev%2 == 1:
				s = c + s
			else:
				s = s + c
		else:
			if rev%2 == 0:
				s = c + s
			else:
				s = s + c
if rev%2 == 1:
	s = s[::-1]
print(s)

### FIXED CODE ###

s = input()
q = int(input())

prev = ""
aft = ""
rev = 0
for i in range(q):
	g = input()
	if len(g) == 1:
		rev += 1
	else:
		f = int(g[2])
		c = g[4]
		if f == 2:
			if rev%2 == 1:
				prev = c + prev
			else:
				aft = aft + c
		else:
			if rev%2 == 0:
				prev = c + prev
			else:
				aft = aft + c
if rev%2 == 1:
	print(aft[::-1]+s[::-1]+prev[::-1])
else:
	print(prev+s+aft)
### BUGGY CODE ###

n = int(input())
cnt = 0
for i in range(1, n+1):
    for j in range(1, n+1):
        for k in range(1, n+1):
            if (i * j) + k == n:
                cnt+=1
print(cnt)

### FIXED CODE ###

n = int(input())
ans = 0
'''
A*B<=N-1となるAとBの組み合わせが何通りあるかを調べること
この考えを導きだせるかが、この問題を解くカギとなる
Cの最小値1を右辺に移項してN-1となっている
不等式となっている点がポイント
Cの最小値1としておけばAとBの組み合わせを全部考えることができる
次に、AとBどちらでも良いが、あるA（もしくはB）が1つの値を決めたときに、
それに対応するB（もしくはA）が何通りあるかを計算して、A（もしくはB）の値をn-1まで
計算して足してあげれば答えとなる
とてもシンプルなコードだけどこれでACとなるはず
'''

for i in range(1,n):
    #print(i, (n-1)//i)
    ans += (n-1)//i
print(ans)
### BUGGY CODE ###

import math
import numpy as np

n,k=(int(x) for x in input().split())
a = [int(x) for x in input().split()]


for _ in range(k):
    new_a = []
    c = 0
    a_in = [max(i-j,0) for i,j in enumerate(a)]
    a_out = [min(i+j,n) for i,j in enumerate(a)]
    for x in range(n):
        c += a_in.count(x)
        c -= a_out.count(x-1)
        new_a.append(c)
    a = new_a
    if np.all(a==n):
        break

print(" ".join([str(x) for x in a]))

### FIXED CODE ###

import math
import numpy as np

n,k=(int(x) for x in input().split())
a = [int(x) for x in input().split()]


for _ in range(k):
    new_a = np.zeros(n+1,dtype=int)
    np.add.at(new_a, np.maximum(0,np.arange(0, n)-a), 1)
    np.add.at(new_a, np.minimum(n,np.arange(0, n)+a+1), -1)
    a = new_a.cumsum()[:-1]
    if np.all(a==n):
        break

print(" ".join([str(x) for x in a]))
### BUGGY CODE ###

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

opes = [0] * (K+1)
for i in range(2**N):
    blue_cnt = 0
    ope_count = 0
    operating = False
    bin2str = format(i, '0' + str(N) + 'b')
    if bin2str.count('1') != K:
        continue
    for j in range(N):
        if blue_cnt > K:
            break
        elif j == (N - 1):
            if int(bin2str[-1]) == 1:
                blue_cnt += 1
                ope_count += 1
            elif operating:
                ope_count += 1
        elif operating and int(bin2str[j:j+1:]) == 0:
            operating = False
            ope_count += 1
        elif operating == False and int(bin2str[j:j+1:]) == 1:
            operating = True
            blue_cnt += 1
        elif operating and int(bin2str[j:j+1:]) == 1:
            blue_cnt += 1
    if blue_cnt == K:
        opes[ope_count] += 1
for i in opes[1::]:
    print(i%100000007)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10000)

nCr = {}
def combination(n, r):
    if r == 0 or r == n: return 1
    if r == 1: return n
    if (n,r) in nCr: return nCr[(n,r)]
    nCr[(n,r)] = combination(n-1,r) + combination(n-1,r-1)
    return nCr[(n,r)]

N, K = map(int, input().split())
for i in range(1, K+1):
	if i <= N-K+1:
		A = combination(N-K+1, i)
		P = combination(K-1, i-1)
		B = A * P
		print(B % (10**9+7))
	else:
		print(0)
### BUGGY CODE ###

N, K, Q = map(int, input().split())
A = []
for q in range(Q):
    a = int(input())
    A.append(a)
import numpy as np
points = np.array([K for i in range(N)])
for a in A:
    points -= 1
    points[a-1] += 1
for p in points:
    if p > 0:
        print('Yes')
    else:
        print('No')

### FIXED CODE ###

import numpy as np
N, K, Q = map(int, input().split())
A = []
for q in range(Q):
    a = int(input())
    A.append(a)
points2 = np.zeros(N)
for a in A:
    points2[a-1] += 1
results = []
for p in points2:
    if K - (Q - p) > 0:
        print('Yes')
    else:
        print('No')