peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
import sys

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


def solve():
    a, b, c, d = map(int, rl().split())
    if c % b != 0:
        print('No')
        exit()
    if c % b != 1:
        print('Yes')
    

if __name__ == '__main__':
    solve()
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))

kisu=[]
gusu=[]
for x in range(n):
  if (x+1)%2==1:
    kisu.append(a[x])
  else:
    gusu.append(a[x])
    
if n%2==0:
  gusu.reverse()
  ans=gusu+kisu
  
else:
  kisu.reverse()
  ans=kisu+gusu
  
ans1=[str(f) for f in ans]

ans1=' '.join(ans1)

print(ans1)
# Judge status: Wrong Answer
import fractions

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

mod = 10**9+7

R = 1 # 最小公倍数
# 最小公倍数を求める
for A in A_list:
    R *= A // fractions.gcd(R, A)

# Bの合計を求める
ans = 0
for A in A_list:
    ans = ans + R // A # 計算は小数として出してはダメだから//を使う

ans %= mod+7

print(ans)
# Judge status: Accepted
import math

H, A = [int(x) for x in input().split()]
print(math.ceil(H/A))
# Judge status: Wrong Answer
N,M=map(int,input().split())
if N >= 2 or M >= 2:
  print(N*(N-1)/2+M*(M-1)/2)
else:
  print(0)
# Judge status: Wrong Answer
l = 'abcdefghijklmnopjrstuvwxwyz'
c = input()
print(l[l.index(c)+1])
# Judge status: Accepted
a,b=map(int,input().split())
print(a if a<=b else a-1)
# Judge status: Accepted
import operator

N, T = [int(i) for i in input().split()]
ct_list = [ [int(i) for i in input().split()] for j in range(N)]

tmp = list(filter(lambda x: operator.ge(T,x[1]), ct_list))

ans = min(tmp, key=lambda x: x[0])[0] if len(tmp) != 0 else "TLE"
print(ans)
# Judge status: Accepted
N = int(input())
S = input()
alpha = [0]*123
mod = 10**9+7

for n in S:
    num = ord(n)
    alpha[num] += 1
    
ans = 1
for i in range(97,123):
    ans *= (alpha[i]+1)%mod

ans -= 1
ans %= mod
print(ans)
# Judge status: Wrong Answer
def readints():
    return list(map(int, input().split()))


a, b, c, d = map(int, input().split())
if abs(a-b) <= d or abs(b-c) <= d or abs(a-c) <= d:
    print("Yes")
    exit()
if a == b == c:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
A,V = input().split()
B,W = input().split()

A = int(A)
V = int(V)
B = int(B)
W = int(W)

T = int(input())

distance = B-A
closer = W-V

def solve():
    if closer >= 0:
        print("NO")
        return
    time = distance/abs(closer)
    if time <= T and B + W * time <= 10**9:
        print("YES")
        return
    else:
        print("NO")
        return
solve()
# Judge status: Accepted
A, B, C, X = int(input()), int(input()), int(input()), int(input())

answer = 0
for a in range(A + 1):
  for b in range(B + 1):
    for c in range(C + 1):
      if a * 500 + b * 100 + c * 50 == X:
        answer += 1

print(answer)
# Judge status: Accepted
n = int(input())
dat = list(map(int, input().split()))
dat.sort()
#import collections
#c = list(collections.Counter(dat))
#c.sort()
#print(c)
#l = len(c)
res = 0
for i in range(n):
    for j in range(i+1, n):
        for k in range(j + 1, n):
            a,b,c = dat[i], dat[j], dat[k]
            if a == b or a == c or b == c:
                continue
            if c < a+b:
                res += 1
print(res)
# Judge status: Accepted
D = int(input())

if D == 25:
  print("Christmas")
elif D == 24:
  print("Christmas Eve")
elif D == 23:
  print("Christmas Eve Eve")
else:
  print("Christmas Eve Eve Eve")
# Judge status: Accepted
N,M = map(int, input().split())

goodObservatory = [1]*N

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

for i in range(M):
	A,B = map(int, input().split())
	if H[A-1] > H[B-1]:
		goodObservatory[B-1] = 0
	elif H[A-1] < H[B-1]:
		goodObservatory[A-1] = 0
	elif H[A-1] == H[B-1]:
		goodObservatory[A-1] = 0
		goodObservatory[B-1] = 0

print(sum(goodObservatory))
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))
c = []
other = 0
for a in A:
    if a< 400:c.append(1)
    elif a < 800: c.append(2)
    elif a < 1200: c.append(3)
    elif a < 1600: c.append(4)
    elif a < 2000: c.append(5)
    elif a < 2400: c.append(6)
    elif a < 2800: c.append(7)
    elif a < 3200: c.append(8)
    else: other+=1
c = set(c)
if c: print(len(c), len(c)+other)
else: print(1, other)
# Judge status: Wrong Answer
n = int(input())
alist = list(map(int,input().split()))

from itertools import combinations
  
perm = combinations(alist,len(alist)-1)

ans = []
for i in perm:
    xor = 0 
    for j in i:
        xor ^= j
    ans.append(xor)

print(" ".join(str(x) for x in ans))
# Judge status: Accepted
n = int(input())
l = []
c = 1
while n != 0:
    if n % 2**c !=0:
        n -= (-2)**(c-1)
        l.append('1')
    
    else:
        l.append('0')
    
    c += 1

if len(l) == 0:
    print('0')

else:
    print(''.join(reversed(l)))
# Judge status: Accepted
import collections

s = input()

mod = 2019
n = len(s)
t = [0]*(n+1)
for i in range(1,n+1):
    t[i] = (t[i-1] + int(s[n-i]) * pow(10, i-1, mod)) % mod
c = collections.Counter(t)
num = c.values()
ans = 0
for i in num:
    ans += i*(i-1) // 2

print(ans)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
A.sort()
from bisect import bisect_left, bisect_right
ans = 0
for i in range(N - 1):
    for j in range(i + 1, N):
        if bisect_left(A, A[i] + A[j]) != bisect_right(A, A[i] + A[j]):
            ans += bisect_left(A, A[i] + A[j]) - bisect_right(A, A[j]) - 1
        else:
            ans += bisect_left(A, A[i] + A[j]) - bisect_right(A, A[j])
print(ans)
# Judge status: Wrong Answer
import sys


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


H, N = inpl()
AB = [inpl() for i in range(N)]
AB.sort()

ans = [0] + [AB[0][1]] * AB[0][0] + [sys.maxsize for i in range(H - AB[0][0])]

for a, b in AB:
    # print(a, b, ans)
    for h in range(min(a, H), H + 1):
        # print(h)
        if h - a > 0:
            ans[h] = min(ans[h], ans[h - a] + b)
        else:
            ans[h] = min(ans[h], b)
    # print(ans)

print(ans[H])
# Judge status: Wrong Answer
N = int(input())
L = [int(i) for i in input().split()]

if max(L) < sum(L) - max(L):
    print("Yes")
else:
    print("Np")
# Judge status: Accepted
from functools import lru_cache
import sys

sys.setrecursionlimit(10 ** 7)


@lru_cache(maxsize=None)
def dfs(h):
    if h == 1:
        return 1
    return 1 + dfs(h // 2) * 2


def main():
    h = int(input())
    print(dfs(h))


if __name__ == '__main__':
    main()

#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
# Judge status: Wrong Answer
a = int()

print(int(a*(a+1)/2))
# Judge status: Accepted
n,m = map(int,input().split())
x_li = [0]*m
y_li = [0]*m
for i in range(m):
    x_li[i],y_li[i]=map(int,input().split())

map_li = [1]*n
red = [False]*n
red[0]=True

for i in range(m):
    x,y = x_li[i],y_li[i]
    x,y = x-1,y-1
    if red[x] and map_li[x]>1:
        red[y]=True
    elif red[x]:
        red[y]=True
        red[x]=False
    map_li[x]-=1
    map_li[y]+=1
#print(map_li)
print(sum(red))
# Judge status: Wrong Answer
def resolve():
	s = input()
	k = int(input())
	if len(s) == 1:
		print(s)
		return

	for i in s:
		if int(i) == 1:
			continue
		print(i)
		return
resolve()
# Judge status: Accepted
import numpy as np
N, W = map(int, input().split())
w, v = [], []
for i in range(N):
    a, b = map(int, input().split())
    w += [a]
    v += [b]
 
DP = np.zeros(W+1, dtype=int)
# i 円以下で買える商品の最大価値
for i in range(N):
    DP[w[i]:] = np.maximum(DP[:-w[i]]+ v[i], DP[w[i]:])
print(DP[-1])
# Judge status: Accepted
N = '0' + input()
L = len(N)

INF = float('inf')
dp = [[INF] * 2 for _ in range(L + 1)]
dp[0][0] = 0

for i in range(L):
    x = int(N[L - 1 - i])
    for j in range(2):
        for a in range(10):
            b = a - j - x
            temp1 = dp[i][j] + a + (b + 10 * (b < 0))
            temp2 = dp[i + 1][b < 0]
            dp[i + 1][b < 0] = min(temp1, temp2)

print(dp[L][0])
# Judge status: Accepted
N,M = map(int,input().split())
A = set()
B = set()
for i in range(M):
  a,b = input().split()
  if a =='1':
    A.add(b)
  if b == str(N):
    B.add(a)
if A&B:
  print('POSSIBLE')
else:
  print('IMPOSSIBLE')
# Judge status: Wrong Answer
s = input()
t = input()

l = len(s)
c = 0
for i in range(0, l):
  if s[i]==t[i]:
    c+=1
# Judge status: Wrong Answer
x = int(input())

if x == 1:
    print(1)
else:
    cur = 0
    for i in range(0, 44720):
        cur += i
        if x <= cur:
            print(i)
            break
# Judge status: Wrong Answer
N = int(input())
v = list(map(int,input().split()))
v.sort()
ans = (v[0] + v[1])/2
for i in range(2,N):
  ans = (ans + v[i])/2
print(ans)
print(v)
# Judge status: Wrong Answer
import sys

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
    n = I()
    A = LI()
    min_a = min(A)
    if sum(list(map(lambda x: x%min_a, A))) > 0:
        print(1)
    else:
        print(min_a)

if __name__ == '__main__':
    main()
# Judge status: Accepted
N,K = map(int, input().split())
A = [int(i) for i in input().split()]

ans = 0
now = 1
while True:
    now += K - 1
    ans += 1

    if now >= N:
        break

print(ans)
# Judge status: Accepted
N = int(input())
if N%2 == 0:
  print(N//2)
else:
  print(N//2+1)
# Judge status: Accepted
N, M = map(int, input().split())
N, M = min(N,M), max(N,M)

ans = [[1], [2, 0], [3, 0, 9], [2, 0, 6, 4]]
if M <= 4:
  print(ans[M-1][N-1])
  exit()
if N == 1:
  print(M-2)
  exit()
if N == 2:
  print(0)
  exit()
if N == 3:
  print(N*M - 6)
  exit()

print(4 + (N-4 + M-4)*2 + (N-4)*(M-4))
# Judge status: Accepted
import fractions
A,B,C,D = map(int,input().split())
def numbers(N,C,D):
  G = fractions.gcd(C,D)
  lcm = (C*D)//G
  return N - N//C - N//D + N//lcm
print(int(numbers(B,C,D)-numbers(A-1,C,D)))
# Judge status: Wrong Answer
n = int(input()) 
a_list = list(map(int, input().split()))
res = sorted(range(n), key=lambda k: a_list[k])
print(list(map(lambda x: x+1, res)))
# Judge status: Accepted
MOD = 10 ** 9 + 7

n, m = map(int, input().split())
a_s = [int(input()) for _ in range(m)] + [n + 1]
dp = [0 for _ in range(n + 1)]
dp[0] = 1
a_pos = 0
for i in range(1, n + 1):
    if a_s[a_pos] == i:
        a_pos += 1
        continue
    dp[i] = dp[i - 1] + dp[i - 2]
    dp[i] %= MOD
print(dp[-1])
# Judge status: Accepted
n, *aa = map(int, open(0).read().split())

bb = sorted(aa)

f, s = bb[-1], bb[-2]

for a in aa:
    if a == f:
        print(s)
    else:
        print(f)
# Judge status: Accepted
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())

N,H = MI()
X = []
for i in range(N):
    a,b = MI()
    X.append((a,0))
    X.append((b,1))

X.sort(reverse=True)

i = 0
ans = 0
while H > 0:
    x,y = X[i]
    if y == 1:
        H -= x
        i += 1
        ans += 1
    else:
        ans += (H+x-1)//x
        break

print(ans)
# Judge status: Accepted
N,M = map(int,input().split())
A = [];B = []
for i in range(N):
  temp = str(input())
  temp = list(temp)
  A.append(temp)
for i in range(M):
  temp = str(input())
  temp = list(temp)
  B.append(temp)
#print(A,B)
for i in range(N-M+1): #0~N-M
  for j in range(N-M+1): 
    Flag = True
    for p in range(M):
      for q in range(M):
        #print(i+p,j+q,p,q)
        if A[i+p][j+q] != B[p][q]:
          Flag = False
    if Flag:
      print("Yes")
      exit()
print("No")
# Judge status: Accepted
n = int(input())
if n<=999:
  print("ABC")
else:
  print("ABD")
# Judge status: Wrong Answer
# inputs = list(map(int, (input().split())))

a = input()

hi = "hi"

for i in range(5):
    if a == hi:
        print("Yes")
        exit(0)
    hi = hi + hi
print("No")
# Judge status: Accepted
A,B = map(int, input().split())
if A <= 9 and B <= 9:
    ans = A*B
else: ans = "-1" 
print(ans)
# Judge status: Accepted
from collections import Counter
n = int(input())
ltr = input()

res = 0
for i in range(n):
    s = Counter(ltr[:i]) & Counter(ltr[i:])
    res = max(res, len(s))
print(res)
# Judge status: Accepted
def main():
    X, Y = map(int, input().split())
    if X % Y == 0:
        print(-1)
    else:
        print(X)



if __name__ == "__main__":
    main()
# Judge status: Accepted
Q,H,S,D = map(int,input().split())
N = int(input())
m_1 = min(Q*4,H*2,S)
m_2 = min(Q*8,H*4,S*2,D)
if N == 1:
    print(m_1)
else:
    if N % 2 == 0:
        print(m_2*(N//2))
    else:
        print(m_2*(N//2)+m_1)
# Judge status: Accepted
n,k=map(int,input().split())
ans=0
for i in range(1,n+1):
    temp=1.0
    num=i
    while num<k:
        num*=2
        temp/=2.0
    ans+=temp
print(ans/n)
# Judge status: Accepted
A,B,C = list(map(int, input().split()))

if ((A < C) and (B > C)) or ((A > C) and (B < C)):
    print("Yes")
else:
        print("No")
# Judge status: Wrong Answer
n = int(input())
H = list(map(int, input().split()))
H2 = [0]*n
H3 = [0]*n

for i in range(n):
  H2[i] = H[i] - i 
  H3[i] = H[i] + i
  

import collections 
c2 = collections.Counter(H2)
c3 = collections.Counter(H3)

ans = 0
for k2 in c2:
  val = -k2
  if val in c3:
    ans += c3[val]
print(ans)  
#iB - iA = Ha + Hb
# Hb - iB = - (iA + Ha)
# Judge status: Wrong Answer
n = int(input())
res = []
x = n
y = 2
while y*y <= x:
    while x % y == 0:
        res.append(y)
        x //= y
    y += 1
if x > 1:
    res.append(x)

res.sort()
a = 1
b = 1
c = 0
while res:
    if c % 2 == 0:
        a *= res.pop()
    else:
        b *= res.pop()
    c+=1
print(a-1+b-1)
# Judge status: Accepted
N,M = map(int,input().split())
if N > M:
  ans = str(M)*N
else:
  ans = str(N)*M
print(ans)
# Judge status: Accepted
n,m=map(int,input().split())
val=min(n,m//2)
#print(val,end=' val\n')
n-=val
m-=2*val
ans=val
#print(m,end=' m\n')
ans+=m//4
print(ans)
# Judge status: Accepted
n=int(input())
s=input()
t=input()

n_s=len(s)
n_t=len(t)
l=[]
for i in range(n_s):
    for j in range(n_t):
        l.append(s[:i]+t[j:])
ans=s+t
for c in l:
    if c[:n_s]==s and c[len(c)-n_t:]==t:
        if len(ans)>len(c):
            ans=c

print(len(ans))
# Judge status: Accepted
import math
import numpy
 
a,b,c = map(int, input().split())
 
if c-a-b > 0 and 4*a*b < (c-a-b)**2:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
print("Yes" if input() == input()[:-1] else "No")
# Judge status: Wrong Answer
date=str(input())
date.replace("2017","2018")
print(date)
# Judge status: Wrong Answer
import sys


inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

n ,c, k = inintm()

T = []
ans = 1

for _ in range(n):
    T.append(inint())

T.sort()

f = T[0]
cnt = 0

for i in range(1,n):
    if T[i] - f < k and cnt <= c:
        continue
    else:
        f = T[i]
        ans += 1
        cnt = 0

print(ans)
# Judge status: Accepted
# A - Maximize the Formula
a,b,c=list(input().split())
l=[]
l=sorted([a,b,c],reverse=True)
print(eval(l[0]+l[1]+"+"+l[2]))
# Judge status: Accepted
d=int(input())
C=list(map(int,input().split()))
S=[]
for i in range(d):
    S.append(list(map(int,input().split())))


last=[0]*26

for i in range(d):
    s=-1
    for j in range(26):
        temp=S[i][j]+C[j]*(i+1-last[j])
        if temp>s:
            s=temp
            index=j
    last[index]=i+1
    print(index+1)
# Judge status: Accepted
def main():
    s = input().rstrip()
    s = "0" + s
    dp = [0, float("inf")]
    for c in s:
        x = int(c)
        dp = [min(dp[0] + x, dp[1] + (10-x)), min(dp[0] + x+1, dp[1] + (10-x) - 1)]
    print(dp[0])

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
a,b,c,d = map (int, input ().split ())
if b < 0 and d < 0:
  print (a*c)
elif b > 0 and d > 0:
  print (b*d)
else:
  if a < 0 and c < 0:
    print (a*c)
  elif a < 0:
    print (b*c)
  else:
    print (a*d)
# Judge status: Accepted
# 1 軒のホテルがあります。 このホテルの宿泊費は、次のようになっています。
# 最初の K 泊までは、 1 泊あたり X 円 K + 1 泊目以降は、 1 泊あたり Y 円 高橋君は、このホテルに N 泊連続で宿泊することにしました。
# 高橋君の宿泊費は合計で何円になるか求めてください。

N = int(input())
K = int(input())
X = int(input())
Y = int(input())

if N - K >= 1:
    print((X * K) + (Y * (N - K)))

else:
    print(X * N)
# Judge status: Accepted
n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))
cb = []
for i in range(m):
    b, c = map(int, input().split())
    cb.append([c, b])
cb.sort(reverse=True)

now = 0
for i in range(n):
    if a[i] < cb[now][0] and cb[now][1] > 0:
        a[i] = cb[now][0]
        cb[now][1] -= 1
    if cb[now][1] == 0:
        now += 1
    if now >= len(cb):
        break
print(sum(a))
# Judge status: Wrong Answer
""" A
"""
import sys
import math
from functools import reduce
from bisect import bisect_left

def readString():
    return sys.stdin.readline()

def readInteger():
    return int(readString())

def readStringSet(n):
    return sys.stdin.readline().split(" ")[:n]

def readIntegerSet(n):
    return list(map(int, readStringSet(n)))

def readIntegerMatrix(n, m):
    return [lambda _: readIntegerSet(m) for _ in range(0, n)]

def main(S):
    return S + "es" if S.endswith("s") else S + "s"

if __name__ == "__main__":
    _S = readString()

    print(main(_S))
# Judge status: Accepted
S = input()
for i in range(1, len(S)):
    if (len(S) - i) % 2 == 0:
        tmp = S[:len(S)-i]
        left = tmp[:len(tmp)//2]
        right = tmp[len(tmp)//2:]
        if left == right:
            print(len(S) - i)
            exit()
print(0)
# Judge status: Accepted
d = dict(zip( ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'], '6543217'))
s = input()
print(d[s])
# Judge status: Wrong Answer
import math
N=int(input())
ans=[0]*(N+1)
tempn=0
xmax=int(math.sqrt(N))+2
for x in range(1,xmax+2):
    ymax=xmax-x
    for y in range(1,ymax+1):    
        zmax=ymax-y
        for z in range(1,zmax+1):
            tempn=((x+y+z)**2-(x*y+y*z+z*x))
            if tempn <= N:
                ans[tempn]+=1
for i in range(1,(N+1)):
    print(ans[i])
# Judge status: Accepted
S = input()
T = input()
l = len(S)
for i in range(1, l+1):
    if S[-i:]+S[:-i]==T:
        print('Yes')
        break
else:
    print('No')
# Judge status: Accepted
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
    A[i] -= i+1
A.sort()
b = A[N//2]
answer = 0
for i in range(N):
    answer += abs(A[i] - b)

print(answer)
# Judge status: Wrong Answer
N,K=(int(x) for x in input().split())
p = list(map(int, input().split()))

p = p.sort

K = 0
for i in range(K):
    K = K+p(i)

print(K)
# Judge status: Accepted
#!/usr/bin/env python
# coding: utf-8

# In[2]:


import math


# In[47]:


N = int(input())


# In[48]:


x = int(-(-math.sqrt(N*2)//1))
y = x*(x+1)//2
diff = y - N
while diff > x:
    diff -= x
    x -= 1
for i in range(1,x+1):
    if i != diff:
        print(i)


# In[ ]:
# Judge status: Wrong Answer
N = int(input())

result = 0
if len(str(N)) % 2 == 0:
    loop = ((len(str(N)) - 1) -1) //2 + 1
    #print(loop)
    for i in range(loop):
        result += 9 * pow(10,2*i)
else:
    for i in range(len(str(N)) - 2):
        result += 9 * pow(10,i)
    result += N - pow(10,len(str(N)) - 1) + 1

print(result)
# Judge status: Accepted
s = list(str(input()))
if s[2] == s[3] and s[4] == s[5]:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
x,y,z = map(int, input().split())
print(z,x,y)
# Judge status: Accepted
n,k=map(int,input().split())
a=list(map(int,input().split()))
for _ in range(min(k,int(n**0.5)+10)):
  add_a=[0]*(n+1)
  for i in range(n):
    a[i]
    add_a[max(0,i-a[i])]+=1
    add_a[min(n,i+a[i]+1)]-=1
  tmp=0
  for i in range(n):
    tmp+=add_a[i]
    a[i]=tmp
print(' '.join(map(str,a)))
# Judge status: Accepted
x=int(input())
isNotPrime=True
while isNotPrime:
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            break
    else:
        break
    x+=1
print(x)
# Judge status: Wrong Answer
N=int(input())
H=list(map(int,input().split()))
A,a=0,0
C=[0]*N
H=H[::-1]
print(H)
for i in range(N-1):
  if H[i]<=H[i+1]:
    A+=1
  else:
    C[a]=A
    a+=1
    A=0
print(max(C))
# Judge status: Wrong Answer
nums=list(map(int,input().split()))
if(nums[0]>=nums[1]):
    print(nums[0]*10+nums[1]+nums[2])
else:print(nums[0]+nums[1]*10+nums[2])
# Judge status: Accepted
#!/usr/bin/env python3
H, A = map(int,input().split())
count=0
while H>0:
    count+=1
    H-=A
print(count)
# Judge status: Wrong Answer
a,b,c,k = map(int,input().split())

x = abs(a-b)
if x > 10**18:
    print('Unfair')
else:
    print(x)
# Judge status: Wrong Answer
N,M = map(int,input().split())
H = input().split()
good = [1]*N
import collections

for i in range(M):
  a,b = map(int,input().split())
  if int(H[a-1]) > int(H[b-1]):
    good[b-1] = 0
  elif int(H[a-1]) < int(H[b-1]):
    good[b-1] = 0
  else:
    good[a-1] = 0
    good[b-1] = 0
    
c = collections.Counter(good)
print(c[1])
# Judge status: Wrong Answer
n,m = map(int, input().split())
s = [tuple(map(int,input().split())) for _ in range(n)]
c = [tuple(map(int,input().split())) for _ in range(m)]
for i in range(n):
  mini = 0
  m_i = 0
  for j in range(m):
    dis = abs(s[i][0]-c[j][0])+abs(s[i][1]-c[j][1])
    print(mini, dis)
    if j==0:
      mini, m_i = dis, j+1
      continue
    elif mini > dis:
      mini, m_i = dis, j+1
  print(m_i)
# Judge status: Wrong Answer
import math

x,y = map(int,input().split())

b = math.floor(y/x)
a = math.floor(math.log(b,2))

print(a+1)
# Judge status: Accepted
n, m = map(int, input().split())
a = list(map(int, input().split()))

a.sort()
a.reverse()

s = sum(a)
for i in range(m):
    if a[i] < s / (4 * m):
        print('No')
        exit(0)

print('Yes')
# Judge status: Accepted
H = int(input())
A = []
A.append((H, 1))
ans = 0
while len(A) > 0:
    h, c = A[0]
    A.pop(0)
    ans += c
    if h != 1:
        A.append((h//2, c*2))
print(ans)
# Judge status: Wrong Answer
MM = input().split()
a = int(MM[0])
b = int(MM[1])
list1=[]
total = 0
for i in range(1,1000):
  aa = total + i
  list1.append(aa)
  total = aa

for i in range(0,998):
  
  for j in range(999):
    if list1[i] == a + j and list1[i+1] == b + j:
      print(j)
# Judge status: Wrong Answer
N,X,T=map(int,input().split())
for i in range(0,1000):
    if X*i>=N:
        print(T*i)
        break
# Judge status: Wrong Answer
def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

n = i()
s = {}
for i in range(n):
	S,P = map(str,input().split())
	s[i+1] = [S, -int(P)]

note = sorted(s.items(), key=lambda x: (x[1][0],x[1][1]) )
for i in note:
	print(i[0])
print(note)
# Judge status: Wrong Answer
from itertools import combinations
S = int(input())
n = S // 3
ans = -1
print(ans)
# Judge status: Accepted
a, b = map(int, input().split())

s = 0
for i in range(1, 1000):
    s += i
    if i == b - a:
        print(s - b)
        exit
# Judge status: Wrong Answer
def ABC_120_A():
    A,B,C = map(int, input().split())
    if A*B >= A*C:
        print(C)
    else:
        print(int(B/A))

if __name__ == '__main__':

    ABC_120_A()
# Judge status: Accepted
x = int(input())
my_money = 100
ans = 0

while my_money<x:
  ans += 1
  my_money += my_money//100
print(ans)
# Judge status: Wrong Answer
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=sum(b)-sum(a)
co=0
for i in range(n):
    if a[i]>b[i]:
        co+=a[i]-b[i]
    else:
        co+=(b[i]-a[i]+1)//2
print('Yes' if c==co else 'No')
# Judge status: Wrong Answer
import math

H = int(input())
W = int(input())
N = int(input())

if(H >= W):
  print(math.ceil(N // H))
else:
  print(math.ceil(N // W))
# Judge status: Accepted
a, b = map(int, input().split())

print(a * b)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
cnt = [0] * int(1e6)
for i in a:
    cnt[i-1] += 1
    cnt[i] += 1
    cnt[i+1] += 1
print(max(cnt))
# Judge status: Accepted
x=int(input())
print(10-x//200)
# Judge status: Accepted
X=int(input())
ans=0

for i in range(1,100):
  for j in range(2,20):
    if i**j<=X:
      ans=max(ans,i**j)
      
print(ans)
# Judge status: Accepted
S = input()
l = len(S)
ideal1 = '10' * (l // 2)
ideal2 = '01' * (l // 2)
if l % 2 == 1:
    ideal1 += '1'
    ideal2 += '0'
cnt1 = 0
cnt2 = 0

for i in range(l):
    if ideal1[i] != S[i]:
        cnt1 += 1
    if ideal2[i] != S[i]:
        cnt2 += 1
print(min(cnt1,cnt2))