peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
a, b, x = map(int, input().split())
if x > (a**2)*b/2:
    t = 2*((a**2)*b-x)/(a**3)
else:
    t = a*(b**2)/(2*x)

import math
ans = math.degrees(math.atan(t))
print(ans)
# Judge status: Wrong Answer
import bisect

N=int(input())

line=[]

for _ in range(N):
    A=int(input())
    index=bisect.bisect_left(line,A)
    if index==0:
        line.insert(index,A)
    else:
        line.pop(index-1)
        line.insert(index,A)

print(len(line))
# Judge status: Accepted
H = int(input())
W = int(input())
N = int(input())

ans = int( N /max([H, W]))
if N%max([H, W]) != 0:
    ans += 1
print(ans)
# Judge status: Accepted
a,b,t = map(int,input().split())

print((t // a) * b)
# Judge status: Accepted
s=int(input())
cnt=1
x=[s]
while True:
  cnt+=1
  if s%2==0:
    s//=2
  else:
    s=3*s+1
  if s not in x:
    x.append(s)
  else:
    print(cnt)
    break
# Judge status: Accepted
from string import ascii_letters, ascii_lowercase, ascii_uppercase

ch = input().rstrip()

if ch in ascii_uppercase:
    print('A')
else:
    print('a')
# Judge status: Accepted
a, b, k = map(int, input().split(' '))

if a >= k:
  print(a - k, b)
elif a + b >= k:
  print(0, b - (k - a))
else:
  print(0, 0)
# Judge status: Wrong Answer
N = int(input())
S = []
for _ in range(N):
    S.append(int(input()))

s = sum(S)
if s % 10 != 0:
    print(s)
else:
    S.sort()
    i = 0
    while s != 0:
        s -= S[i]
        if s % 10 != 0:
            break
        i += 1
    if s % 10 == 0:
        print(0)
    else:
        print(s)
# Judge status: Wrong Answer
def n_pow(a, n):
    if n <= 0:
        return 0
    return pow(a, n)


def main():
    bags, remainder = map(int, input().split())
    biscuits = list(map(int, input().split()))
    count = [0, 0]
    for b in biscuits:
        count[b % 2] += 1
    print(n_pow(2, count[0] + count[1] - 1))


if __name__ == '__main__':
    main()
# Judge status: Accepted
import fractions
n = int(input())
li = [int(input()) for _ in range(n)]

ans = li[0]
for i in range(1,n):
    s = li[i]
    ans = (ans * s) // fractions.gcd(ans, s)

print(ans)
# Judge status: Accepted
s=input()
t=input()
ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1
print(ans)
# Judge status: Accepted
#N=int(input())
#N,M=map(int, input().split())
#L=list(map(int, input().split()))
N,M=map(int, input().split())
ifACL=[0]*N
cWAL=[0]*N
psL=[]
AC=0
WA=0
p=0
s=0
for _ in range(M):
  p,s=map(str, input().split())
  p=int(p)
  if ifACL[p-1]==0 and s=="WA":
    cWAL[p-1]+=1
  elif ifACL[p-1]==0 and s=="AC":
    AC+=1
    WA+=cWAL[p-1]
    ifACL[p-1]=1

print(AC,WA)
# Judge status: Accepted
N = input()
print("YNeos"[not(N[1]==N[2] and (N[0]==N[1] or N[2]==N[3]))::2])
# Judge status: Accepted
dts = input().split()

d = int(dts[0])
t = int(dts[1])
s = int(dts[2])

time = d / s

if time <= t:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
def resolve():
    n = int(input())
    ans = 'No'
    for i in range(1,10):
        for j in range(1,10):
            if i*j == n:
                ans = 'Yes'
    print(ans)
resolve()
# Judge status: Wrong Answer
import collections
n = int(input())


def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a


ans = 0
#print(prime_factorize(n))
a = collections.Counter(prime_factorize(n))
for v in a.values():
    ans += (v+1)//2

print(ans)
# Judge status: Wrong Answer
N,M,K = map(int,input().split())

for i in range(N):
    for j in range(M):
        black = i * (N - j) + j * (M - i) 
        
        if black == K:
            print("Yes")
            exit()
            
print("No")
# Judge status: Accepted
a,b,c = map(int,input().split())
if (a < c < b) or (b < c < a):
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n = int(input())
sp = []
for i in range(n):
  inp = input().split()
  sp.append((inp[0], int(inp[1]), i + 1))

sp.sort(key=lambda x:(x[0], -x[1]))

for i in sp:
  print(i[2])
# Judge status: Accepted
N, M = map(int, input().split())
ac = [False for _ in range(N)]
wa = [0 for _ in range(N)]

ans_wa = 0
for _ in range(M):
  p, S = input().split()
  p = int(p) - 1
  if S == "AC":
    if ac[p] == False:
      ac[p] = True
      ans_wa += wa[p]
  else:
    wa[p] += 1

ans_ac = ac.count(True)
print("{} {}".format(ans_ac, ans_wa))
# Judge status: Accepted
def main():
    N, *X = map(int, open(0).read().split())
    l, r = sorted(X)[N // 2 - 1: N // 2 + 1]
    ans = [r if x < r else l for x in X]
    print("\n".join(map(str, ans)))
    return


main()
# Judge status: Wrong Answer
s = input()
t = ''
for i in s:
    if i == '0':
        t = t + '0'
    elif i == '1':
        t = t + '0'
    else:
        t = t[:-1]
print(t)
# Judge status: Wrong Answer

s1 = input()
s2 = input()
s2 = s2 * 2
for i in range(len(s1)):
    if s2[i] == s1[0]:
        for j in range(len(s1)):
            if s2[i + j] != s1[j]:
                print("No")
                exit()
        
        print("Yes")
        exit()
# Judge status: Accepted
N, M = map(int, input().split())
Q = 1000000007
A = set()
for _ in range(M):
    A.add(int(input()))

p = []
for i in range(1, N+1):
    if i in A:
        p.append(0)
    elif i == 1:
        p.append(1)
    elif i == 2:
        p.append(p[0] + 1)
    else:
        p.append(p[i-2] + p[i-3])

print(p[N-1] % Q)
# Judge status: Wrong Answer
H, W = input().split(' ')
H = int(H)
W = int(W)
print(int(H*W/2 + 0.5))
# Judge status: Accepted
N = int(input())
N1 = N // 10
if N % 2 == 1:
    print(0)
else:
    counter = 0
    div = 10
    while True:
        num = N // div
        if num == 0:
            break
        counter += num
        div *= 5
    print(counter)
# Judge status: Wrong Answer
from collections import defaultdict
N, M = map(int, input().split())
d = defaultdict(int)
for i in range(1, N):
    d[i] = 0
for _ in range(M):
    a, b = map(int, input().split())
    d[a] += 1
    d[b] += 1

for i in d.values():
    print(i)
# Judge status: Wrong Answer
X, N = map(int, input().split())
P =  set(map(int, input().split()))
Nums = set(range(1, 101))
Nums = Nums - P
sorted(Nums)


minNum = 99999;
minIndex = 0;
for n in Nums:
    if abs(X - n)< minNum:
        minNum = abs(X - n)
        minIndex = n

print(minIndex)
# Judge status: Accepted
import bisect

N = int(input())
A = sorted(list(map(int, input().split())))
B = sorted(list(map(int, input().split())))
C = sorted(list(map(int, input().split())))
#print(A)
#print(B)
#print(C)

ans = 0

for i in B:
  a_num = bisect.bisect_left(A,i)
  c_num = bisect.bisect(C,i)
  ans += a_num*(N-c_num)


print(ans)
# Judge status: Wrong Answer
N = int(input())
for i in range(1, N+1):
    if i*i > N:
        print((i-1)*(i-1))
        exit()
# Judge status: Wrong Answer
N = int(input())
A = list(map(int,input().split()))
cnt = 0
for i in range(1,N) :
    if A[i-1] <= A[i] :
        cnt += A[i] - A[i-1]
    else :
        cnt += 0
print(cnt)
# Judge status: Accepted
S = input()
n =len(S)
s = S.lower()


if S[0] != 'A':
  print('WA')
  exit()
else:
  for i in range(2, n-1):
    if S[i] != 'C':
      if S[i] != s[i]:
        print('WA')
        exit()
      
if S[n-1] != s[n-1] or S[1] != s[1]:
  print('WA')
  exit()
  
if S.count('C') != 1:
  print('WA')
  exit()
  
print('AC')
# Judge status: Accepted
n = int(input())
t = input()
if n % 2 != 0:
  print('No')
else:
  print('Yes' if t[:n//2] == t[n//2:] else 'No')
# Judge status: Accepted
from sys import exit
N,K = map(int,input().split())
town = [None]+list(map(int,input().split()))

flag = [None]+[0]*N
remain = K
piece = 1
cnt = 1
while remain > 0:
    if flag[town[piece]] != 0:
        q = cnt-flag[town[piece]]
        piece = town[piece]
        remain -= 1
        break
    else:
        piece = town[piece]
        flag[piece] = cnt
        remain -= 1
        cnt += 1

if remain == 0:
    print(piece)
    exit(0)

remain %= q

while remain > 0:
    piece = town[piece]
    remain -= 1

print(piece)
# Judge status: Accepted
N = int(input())
C = input()

W = 0                  #仕切りより左側の白い石の個数
R = C.count('R')       #仕切りより右側の赤い石の個数

ans = max(W, R)

for i in range(N):
    if C[i] == 'W':    #仕切りの左側に'W'が移動する
        W += 1
    else:              #仕切りの左側に'R'が移動する
        R -= 1
    ans = min(ans, max(W, R))

print(ans)
# Judge status: Accepted
line = list(input())
N = len(line)
i = 1
for i in range(N):
    if line[i] == "?":
        line[i] = "D"
print("".join(line))
# Judge status: Accepted
def main():
    N,K=map(int,input().split())
    h=list(map(int,input().split()))
    ans=[0]*N
    ans[1]=abs(h[1]-h[0])
    for i in range(2,N):
        ans[i]= min(abs(h[i]-h[j])+ans[j] for j in range(max(0,i-K),i))
    print(ans[-1])
main()
# Judge status: Wrong Answer
#!/usr/bin/env python3
s = int(input())
if s <= 10**9:
    print(s, 0, 0, 0, 0, 1)
else:
    print(10**9, 1, 10**9 - int(str(s)[-9:]), s // 10**9 + 1,0,0)
# Judge status: Accepted
d=int(input())
result='Christmas'
n=25
while n>=22:
    if n>d:
        result+=' Eve'
    n-=1
print(result)
# Judge status: Accepted
from statistics import median

A, B, C = [int(x) for x in input().split()]

low = min(A, B, C)
mid = median([A, B, C])
huge = max(A, B, C)

if huge % 2 == 0:
    print(0)
else:
    red = low*mid*(huge//2)
    blue = low*mid*(huge//2+1)

    print(blue-red)
# Judge status: Accepted
s = input()
week=["SAT","FRI","THU","WED","TUE","MON","SUN"]
for i in range(0,7):
    if s == week[i]:
        print(i+1)
# Judge status: Accepted
# C - Make a Rectangle
# https://atcoder.jp/contests/arc081/tasks/arc081_a

from collections import Counter

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

C = sorted(list(Counter(A).items()), key=lambda x: -x[0])

ans = 0
for k, v in C:
  if v >= 4:
    if ans == 0:
      print(k ** 2)
    else:
      print(ans * k)
    exit()
  else:
    if v >= 2:
      if ans == 0:
        ans = k
      else:
        print(ans * k)
        exit()

print(0)
# Judge status: Accepted
x = int(input())

for n in range(1, 10):
    for k in range(1, 10):
        a = n * k
        if a == x:
            print('Yes')
            exit()
        else:
            pass
print('No')
# Judge status: Accepted
import collections

n,k = map(int,input().split())
a = list(map(int,input().split()))

c = collections.Counter(a).most_common()
cnt = len(c)
i = 1
ans = 0
while cnt > k:
    cnt -= 1
    ans += c[-i][1]
    i += 1

print(ans)
# Judge status: Accepted
import bisect
N = int(input())
A = list(map(int, input().split(" ")))
B = list(map(int, input().split(" ")))
C = list(map(int, input().split(" ")))
A.sort()
B.sort()
C.sort()

ans = 0
for b in B:
    i = bisect.bisect_left(A, b)
    j = bisect.bisect_right(C, b)
    ans += i * (N - j)
print(ans)
# Judge status: Wrong Answer
a, b = (int(i) for i in input().split())
if abs(a-b) > 1:
  print(max(a,b)*2 - 1)
else:
  print(a*2)
# Judge status: Wrong Answer
N,K = map(int,input().split())
#N = int(input())
#A = list(map(int,input().split()))
p=list(range(N+1))
c=0
s=sum(p[:K])
S=sum(p[:K])

l=sum(p[len(p)-K:])
L=sum(p[len(p)-K:])
for i in range(K,len(p)):
    s += p[i]
    S += s
    #print(s,S)
    #print(c)
    l += p[len(p)-i-1]
    L += l
#    print(i)
 #   print(l,L)
c = L - S + (N-K+2)
print(c)
# Judge status: Accepted
N, K=map(int, input().split())
S=list(input())

count=0
pre=S[0]
for i in range(1,N):
  if pre==S[i]:
    count+=1
  pre=S[i]

  
  
print(min(N-1, count+2*K))
# Judge status: Wrong Answer
n = int(input())
ans = []
start = "a"
stack = []
stack.append(start)
num = ord("a")
while stack:
    v = stack.pop()
    if len(v) == n:
        ans.append(v)
        continue
    nex_num = ord(v[-1])
    for i in range(num, nex_num + 2):
        tuika = chr(i)
        stack.append(v + tuika)
ans.sort()
print(*ans, sep="\n")
# Judge status: Accepted
N = int(input())
A_list = [int(item)-(index+1) for index, item in enumerate(input().split())]

A_list.sort()
b = A_list[len(A_list)//2]

ans = 0
for i in A_list:
  ans += abs(b-i)

print(ans)
# Judge status: Wrong Answer
x,y,z = map(int, input().split())
print(x//(y+z+1))
# Judge status: Accepted
import sys

def main(n):
    c = "abcdefghijklmnopqrstuvwxyz"
    m = {}
    for i in range(0, 26):
        m[i+1] = c[i]

    s = ""
    while n > 0:
        if n%26 == 0:
            t = 26
            n //= 26
            n -= 1
        else:
            t = n%26
            n //= 26
        s = m[t] + s
    return s

n = int(sys.stdin.readline().strip())
print(main(n))
# Judge status: Accepted
#import math  
import fractions
from functools import reduce

N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

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

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)
ans = lcm_list(T)

print(ans)
# Judge status: Accepted
s = list(input())
n = len(s)
c = 0
for i in range(n - 1):
    if s[i] == s[i + 1]:
        if s[i] == '0':
            s[i + 1] = '1'
        else:
            s[i + 1] = '0'
        c += 1
print(c)
# Judge status: Wrong Answer
x=int(input())
if x<=100:
    print(0)
    exit()
if x>=2100:
    print(1)
    exit()
else:
    t=x//100
    a=x%100
    if t<=a<=t*5:
        print(1)
    else:
        print(0)
# Judge status: Wrong Answer
N = int(input())
XL =[list(map(int, input().split())) for _ in range(N)]
LR = [[XL[i][0] - XL[i][1], XL[i][0] + XL[i][1]] for i in range(N)]
LR.sort()

cp = LR[0][1]

ans = 0

for i in range(1,N):
	if LR[i][0] < cp:
		ans += 1
	else:
		cp = LR[i][1]
print(N-ans)
# Judge status: Wrong Answer
s = input()
print('Good' if all(s[i]==s[i+1] for i in range(3)) else 'Bad')
# Judge status: Accepted
import heapq
n=int(input())
a=list(map(int,input().split()))

zero_count=0
minus_count=0
for i in range(n):
    if a[i]<0:
        minus_count+=1
    if a[i]==0:
        zero_count+=1
        break

for i in range(n):
    a[i]=abs(a[i])

if zero_count==1 or minus_count%2==0:
    ans=sum(a)
else:
    heapq.heapify(a)
    mn=heapq.heappop(a)
    ans=sum(a)-mn

print(ans)
# Judge status: Accepted
from bisect import bisect_right as br 
from bisect import bisect_left as bl

f=lambda:map(int,input().split())
N=int(input())
A=list(f())
B=list(f())
C=list(f())
A.sort()
B.sort()
C.sort()


B2=[]
C2=[]
for b in B:
    B2.append(bl(A,b))
for c in C:
    C2.append(bl(B,c))
    
B3=[]
for b in B2:
    if B3:
        B3.append(B3[-1]+b)
    else:
        B3.append(b)
    
res=sum([B3[C2[i]-1] if C2[i]!=0 else 0 for i in range(N)])
print(res)
# Judge status: Accepted
a,b = map(int,input().split())

if (a + b) % 2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
# Judge status: Accepted
S = list(input())

i = 0
count = 0
while i < len(S)-1:
  if S[i] != S[i+1]:
    del S[i:i+2]
    count += 2
    if i != 0:
      i -= 1
  else:
    i += 1
print(count)
# Judge status: Accepted
s = input()
k = int(input())
l = "abcdefghijklmnopqrstuvwxyz"
ans = ""
for i in range(len(s) - 1):
    num = (26 - l.index(s[i])) % 26
    if k >= num:
        ans += "a"
        k -= num
    else:
        ans += s[i]
ans += l[(l.index(s[-1]) + k) % 26]
print(ans)
# Judge status: Wrong Answer
x,y=map(int, input().split())
if x==2 and y==2:
  print('Yes')
elif x==2 or y==2:
  print('No')

a=[4,6,9,11]
if (x in a) and (y in a):
  print('Yes')
elif (x not in a) and (y not in a):
  print('Yes')
else:
  print('No')
# Judge status: Accepted
a, b, x = map(int, input().split())
print(b//x - (a-1)//x)
# Judge status: Wrong Answer
w,h,n = map(int,input().split())
x_max = w
x_min = 0
y_max = h
y_min = 0
for i in range(n):
    x,y,a = map(int,input().split())
    if a == 1:
        x_min = max(x_min,x)
    elif a == 2:
        x_max = min(x_max,x)
    elif a == 3:
        y_min = max(y_min,y)
    elif a == 4:
        y_max = min(y_max,y)
    print(x_max,x_min,y_max,y_min)
S = (x_max-x_min)*(y_max-y_min) 
print(S if S>=0 else 0)
# Judge status: Accepted
A=int(input())
B=int(input())
C=int(input())
X=int(input())
ans=0
for ai in range(A+1):
    for bi in range(B+1):
        for ci in range(C+1):
            temp=ai*500+bi*100+ci*50
            if temp==X:
                ans+=1
print(ans)
# Judge status: Accepted
n=input()
if "9" in n:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
w = str(input())

n = int(0)

for i in w:
    if w.count(i) % 2 == 1:
        n += 1

if n == 0:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
S = input()

S = S.replace("eraser","")
S = S.replace("erase","")
S = S.replace("dreamer","")
S = S.replace("dream","")

if len(S) == 0:
    ans = "YES"
else:
    ans = "NO"

print(ans)
# Judge status: Accepted
l, r, d = map(int, input().split())
c = 0
for x in range(l, r+1):
	if x % d == 0:
		c += 1
print(c)
# Judge status: Accepted
n,k = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
for i in range(n - k):
  if x[k+i] > x[i]:
    print('Yes')
  else:
    print('No')
# Judge status: Accepted
import sys

#N = I()
#A = [LI() for _ in range(N)]

a, b = list(map(int,sys.stdin.readline().rstrip().split()))

if a > 0:
    print('Positive')
elif a <= 0 and b >= 0:
    print('Zero')
else:
    if (a+b)%2 == 0:
        print('Negative')
    else:
        print('Positive')
# Judge status: Accepted
import numpy as np

s = np.array(list(map(int, input())))

a01 = np.tile([0,1], len(s)//2+1)
a10 = np.tile([1,0], len(s)//2+1)

if len(s)%2 != 0:
    a01 = np.delete(a01, len(s))
    a10 = np.delete(a10, len(s))
else:
    a01 = np.delete(a01, [len(s)-1,len(s)])
    a10 = np.delete(a10, [len(s)-1,len(s)])

ans01 = np.abs(s -a01)
ans10 = np.abs(s -a10)

if sum(ans01) >= sum(ans10):
    print(sum(ans10))
else:
    print(sum(ans01))
# Judge status: Wrong Answer
from collections import defaultdict
import math
prm = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101]
alp = {chr(i):p for i,p in zip(range(97, 97+26),prm)}
n = int(input())
d = defaultdict(int)
nums = set([])
for _ in range(n):
  s = input()
  m = 1
  for l in s:
    m = m*alp[l]%10**9
  d[m] += 1

def comb(n, r):
  if n<r:
    return 0
  else:
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

ans = 0
for k in d.values():
  ans += comb(k,2)
print(ans)
# Judge status: Accepted
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    x = I()
    ans = x//11*2
    num = x%11
    if num==0:
        pass
    elif num<=6:
        ans += 1
    else:
        ans += 2

    print(ans)
main()
# Judge status: Accepted
amount, num = map(int, input().split())

hated_digit = list(map(str, input().split()))

while True:
    check = 0
    for hd in hated_digit:
        if hd not in str(amount):
            check += 1

        else:
            amount += 1
    if check == num:
        print(amount)
        break
# Judge status: Accepted
a=[]
for i in range(4):
    b=int(input())
    a.append(b)
ans=0
for i in range(1,a[0]+1):
    if i<=a[1]:
        ans+=a[2]
    else:
        ans+=a[3]
print(ans)
# Judge status: Accepted
s = input()
if len(set(s[::2])-{"R","U","D"}) ==0 and len(set(s[1::2])-{"L","U","D"}) ==0 :
    print('Yes')
else:
  print('No')
# Judge status: Accepted
s = input()[-1]

if s in ['2', '4', '5', '7', '9']:
    print('hon')
elif s in ['0', '6', '1', '8']:
    print('pon')
else:
    print('bon')
# Judge status: Wrong Answer
n = int(input())
b = list(map(int, input().split()))
a = [0]*n
for i in range(n-1, 0,  -1):
    if i == n-1:
        a[i] = b[i-1]
    else:
        a[i] = min(a[i+1], b[i-1])
a[0] = b[0]
print(sum(a))
# Judge status: Wrong Answer
p = list(map(int,input().split()))

mn = 200
for i in range(2):
    for j in range(i+1,3):
        if (i+j < mn):
            mn = i+j

print(mn)
# Judge status: Wrong Answer
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    w = input()
    c = collections.Counter()
    for i in c:
        if c[i] % 2 == 1:
            print("No")
            exit()
    print("Yes")
    return 0

if __name__ == "__main__":
    solve()
# Judge status: Accepted
N, K = map(int, input().split())

res = N % K
print(min(res, abs(res - K)))
# Judge status: Accepted
from bisect import bisect_right
import itertools

N, x = map(int, input().split())
a = list(map(int, input().split()))

a.sort()
acum = list(itertools.accumulate(a))

answer = bisect_right(acum, x)
if answer == N:
    if acum[-1] < x:
        answer -= 1
print(answer)
# Judge status: Wrong Answer
x,y,z = map(int, input().split())
if x%(y+z)>=y:
	print(x//(y+z)+1)
else:
	print(x//(y+z))
# Judge status: Accepted
def main():
    n, m  = [int(x) for x in input().split(" ")]

    arr = [int(x) for x in input().split(" ")]

    sum = 0

    for i in arr:
        sum += i

    arr.sort()

    if (arr[n-m] < sum/(4*m)):
        print("No")
    else:
        print("Yes")

main()
# Judge status: Wrong Answer
X=int(input())
n=26

a=[]
X_dumy = X
out = ''
while X_dumy>0:
  out = str(X_dumy%n)
  X_dumy = int(X_dumy/n)
  a.append(out)

l = list('abcdefghijklmnopqrstuvwxyz')
N=0
for x in a:
  a[N]=l[int(a[N])-1]
  N=N+1
a.reverse()
pg = ''.join(a)
print(pg)
# Judge status: Accepted
x = int(input())

time1 = x // 11
X = x % 11
time1 *= 2
if X > 6:
    time1 += 2
elif X > 0:
    time1 += 1
print(time1)
# Judge status: Accepted
_ = int(input())
a = [int(x) for x in input().split()]

answer = 10**100
for y in range(-100, 100 + 1):
    acc = 0
    for x in a:
        acc += (x - y) * (x - y)
    answer = min(answer, acc)
print(answer)
# Judge status: Wrong Answer
n = list(input())
ans = "Good"
for i in range(len(n)):
    if n[i-1] ==n[i]:
        ans = "Bad"
    else:
        pass
print(ans)
# Judge status: Accepted
S = input()

if len(S) % 2 != 0:
    print("No")
else:
    N = int(len(S) / 2)

    flag = 0

    for indx in range(N):
        if ((S[indx * 2 + 0] != "h") or
            (S[indx * 2 + 1] != "i")):
            flag = 1

    if flag == 0:
        print("Yes")
    else:
        print("No")
# Judge status: Wrong Answer
n = int(input())
a = [int(input()) for _ in range(5)]
ind = 0
minimum = 10 ** 18
for i in range(5):
    minimum = min(minimum, a[i])
print((n + minimum) // minimum + 4)
# Judge status: Wrong Answer
n,c,k = map(int,input().split())
t_input = [int(input()) for i in range(n)]

t_s = sorted(t_input)

ans = 0
c_limit = 1
t_limit = t_s[0]*k
for i in range(n):
    t = t_input[i]
    #乗客が前の客の時間制限より大きいか、すでにバスが定員以上なら
    if t>t_limit or c>=c_limit:
        ans+=1
        c_limit=1
        t_limit = t+k
    else:
        c_limit+=1
print(ans)
# Judge status: Wrong Answer
st = input()
st2 = input()
f = st2[len(st2)-1]
lst = []
lst2 = []
for i in st:
  lst.append(i)
for i in st2:
  lst2.append(i)
lst2.remove(f)
yo = "Yes"
for i in range(len(st)):
  if lst[i] != lst2[i] or len(lst)+1!=len(lst2):
    yo = "No"
print(yo)
# Judge status: Accepted
from bisect import bisect_right
N = int(input())
A = [int(input()) for i in range(N)]
A.reverse()
X = [A[0]]

for i in range(1, N):
    if X[-1] <= A[i]:
        X.append(A[i])
    else:
        idx = bisect_right(X, A[i])
        X[idx] = A[i]

print(len(X))
# Judge status: Accepted
H, N = map(int, input().split())
dp = [10**8 for i in range(H+1)]

dp[0] = 0

for i in range(N):
  a, b = map(int, input().split())
  
  for j in range(H):
    dp[min(j+a, H)] = min(dp[min(j+a, H)], dp[j] + b)


print(dp[H])
# Judge status: Accepted
a= input()
b= input()
c= input()
qa=[]
qb=[]
qc=[]
for i in a:
	qa.append(i)
for i in b:
	qb.append(i)
for i in c:
	qc.append(i)
qa.append('d')
qb.append('d')
qc.append('d')
t=qa.pop(0)
while len(qa)>0 and len(qb)>0 and len(qc)>0:
	if t=='a':
		t=qa.pop(0)
	elif t=='b':
		t=qb.pop(0)
	else :
		t=qc.pop(0)

if len(qa)==0:
	print('A')
elif len(qb)==0:
	print('B')
else:
	print('C')
# Judge status: Accepted
#
# 179B
#
n = input()
n = int(n)
s = ''
for i in range(n):
    t = input()
    t = t.replace(' ','')
    t = list(t)
    if t[0]==t[1]:
        s = s+'1'
    else:
        s = s+'0'

if '111' in s:
    print('Yes')
else:
    print('No')