peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
N = int(input())
a = list(map(int,input().split()))
a.sort()
array = list(set(a))
sum = 0
n = 0
for i in range(len(array)):
    cnt = 0
    for j in range(n,len(a)):
        if array[i] == a[j]:
            cnt += 1
        else:
            break
    n += cnt
    if cnt >= array[i]:
        sum += cnt - array[i]
    else:
        sum += cnt
print(sum)
# Judge status: Accepted
A,B,C,D = map(int,input().split())

from math import ceil
if ceil(A/D) >= ceil(C/B):
    print("Yes")
    exit()

print("No")
# Judge status: Wrong Answer
from math import ceil
N, K = map(int, input().split())
n = 1
while K > 2**n:
  n += 1
ans = (1 / N) * (0.5**n)
pre = 1
for i in range(n - 1, -1, -1):
  k = ceil(K / (2**i))
  if N >= k:
    ans += (1 / N) * (k - pre) * (0.5 ** i)
    if N == k:
      break
  else:
    ans += (1 / N) * (N - pre) * (0.5 ** i)
    break
  pre = k
if N > K:
  ans += (1 / N) * (N - K)
print(ans)
# Judge status: Accepted
pat = ["A", "C", "G", "T"]

s = input()

left = right = 0
ans = 0

while left < len(s):
    right = left
    while right < len(s) and s[right] in pat:
        right += 1

    ans = max(ans, right - left)

    left = right + 1

print(ans)
# Judge status: Accepted
n,m=map(int,input().split())
p=[True]*n
y=[0]*n
i=0
l=0
for  _ in range(m):
    k,o=input().split()
    k=int(k)-1
    if p[k]==True:
        if o=="AC":
            i+=1
            p[k]=False
        else:
            y[k]+=1
for e in range(n):
    if p[e]==False:
        l+=y[e]
print(i,l)
# Judge status: Accepted
N = input()
As = input().split()
e = [int(i) for i in As if int(i)%2 == 0]
c = 0
for i in e:
  if i%3==0 or i%5==0:
    c += 1
if c == len(e):
  print("APPROVED")
else:
  print("DENIED")
# Judge status: Accepted
n = int(input())
csf = [list(map(int,input().split())) for _ in range(n-1)]
ans = []
for i in range(n-1):
  time = csf[i][1]+csf[i][0]
  for j in range(i+1,n-1):
    if time < csf[j][1]:
      time = csf[j][1]
    elif (time-csf[j][1]) % csf[j][2] != 0:
      time = csf[j][1]+((time-csf[j][1])//csf[j][2]+1)*csf[j][2]
    time += csf[j][0]
  ans.append(time)
ans.append(0)
for k in range(n):
  print(ans[k])
# Judge status: Accepted

def solve():
    B = [0]*N
    for i in range(N):
        B[i] = a[i] - (i+1)
    B.sort()
    b = B[N//2]
#    print(b)
    scr = 0
    for l in range(N):
        scr += abs(B[l] - b)
    print(scr)

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

if 500*K >= X:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
sx, sy, tx, ty = list(map(int, input().split()))

sol = ""
sol += "R"*(tx-sx) + "U"*(ty-sy) + "L"*(tx-sx) + "D"*(ty-sy)
sol += "D"+ "R"*(tx-sx + 1) + "U"*(ty-sy + 1) + "LU" + "L"*(tx-sx + 1) + "D"*(ty-sy+1) + "R"

print(sol)
# Judge status: Wrong Answer
n,m=map(int,input().split())
a=[[int(i) for i in input().split()] for l in range(n)]
b=[[int(i) for i in input().split()] for l in range(m)]
for A in a:
    c=1
    r=0
    m=100000000
    for B in b:
        k=abs(A[0]-B[0])+abs(A[1]-B[1])
        if m>k:
            m=k
            r=c
        c+=1
    print(r)
# Judge status: Accepted
s = input()
print('Bad' if any(s[i]==s[i+1] for i in range(3)) else 'Good')
# Judge status: Accepted
n = int(input())
a = []
b = []
for i in range(n):
  x,y = map(int,input().split())
  a.append(x)
  b.append(y)
a.sort()
b.sort()
if n % 2 == 1:
  print(b[n//2] - a[n//2] + 1)
else:
  print(b[n//2]+b[n//2-1]-a[n//2]-a[n//2-1]+1)
# Judge status: Accepted
N, M = map(int, input().split())
if N == 1:
  if M == 1:
    print(1)
  elif M == 2:
    print(0)
  else:
    print(M - 2)
elif N == 2:
  print(0)
else:
  if M == 1:
    print(N - 2)
  elif M == 2:
    print(0)
  else:
    print((N - 2) * (M - 2))
# Judge status: Wrong Answer
N = int(input(""))
d = 0
for a in range(N):
  for b in range(N):
    for c in range(N):
      if a*b+c == N:
        d += 1
print(d)
# Judge status: Accepted
n = int(input())
l = list(map(int,input().split()))
x = l[0]
for i in range(1,n):
  x = x^l[i]
  

ans = []
for i in range(n):
  ans.append(str(x^l[i]))
  
print(' '.join(ans))
# Judge status: Wrong Answer
n = int(input())
h = list(map(int, input().split()))
for i in range(1,n):
    if h[i-1] > h[i]:
        h[i-1] -= 1
print("Yes") if h == sorted(h) else print("No")
# Judge status: Accepted
n = int(input())
if n % 2 == 0:
    print(0.5)
else:
    print((n//2+1)/n)
# Judge status: Accepted
n = int(input())

l= []
for i in range(n):
    a  = input()
    l.append(a)
s = set(l)
print(len(s))
# Judge status: Accepted
n = int(input())
x = [int(i) for i in input().split()]
y = []
z =[]
for i in range(len(x)):
    y.append(x[i]+i)
    z.append(i-x[i])
count = 0 
dic = {}
for i in range(len(z)):
    if z[i] in dic :
        dic[z[i]]+= 1
    else :
        dic[z[i]] = 1
for i in range(len(y)) :
    dic[z[i]]-= 1 
    if y[i] in dic :
        count += dic[y[i]]
print(count)
# 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 = int(input())

A = 10**N + 8**N - 2*9**N
B = A%(10**9 + 7)
print(B)
# Judge status: Wrong Answer
x, k, d = map(int, input().split())
x = abs(x)

k_ = x // d
k = k - k_
x = x-k*d

while k > 0:
    x = min(abs(x + d), abs(x - d))
    k -= 1
print(x)
# Judge status: Accepted
n = int(input())
p = list(map(int,input().split()))
c = 0
for i in range(n-2):
    if p[i] < p[i+1] and p[i+1] < p[i+2]:
        c += 1
    elif p[i] > p[i+1] and p[i+1] > p[i+2]:
        c += 1
print(c)
# Judge status: Accepted
a = int(input())
if a in [3,5,7]:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
N,M=map(int,input().split())
AB=list()
for i in range(N):
  AB.append(list(map(int,input().split())))
AB.sort()
ans=0
for i in range(N):
  if M>=AB[i][1]:
    M-=AB[i][1]
    ans+=AB[i][0]*AB[i][1]
  else:
    ans+=M*AB[i][0]
    M=0
print(ans)
# Judge status: Wrong Answer
# -*-  coding:utf-8 -*-

N = int(input())

if N % 10 == (2 or 4 or 5 or 7 or 9):
    print("hon")
elif N % 10 == 3:
    print("bon")
else:
    print("pon")
# Judge status: Accepted
S = input()
if 'a' in S and'b' in S and 'c' in S:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
a = input()
print('Yes' if a[0]==a[1]==a[2] or a[1]==a[2]==a[3] else 'No')
# Judge status: Accepted
length = list(map(int, input().split()))

length.sort()

if length == [5,5,7]:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
import numpy as np
n=int(input())
h=np.array(list(map(int,input().split()))+[0]*2)
dp = np.full(n+2, 10 ** 10, dtype=np.int64)
dp[0] = 0
for i in range(1,n):
    dp[i:i+2]=np.minimum(dp[i:i+2],np.abs(h[i:i+2]-h[i-1])+dp[i-1])
print(dp[n-1])
# Judge status: Accepted
n,l=map(int,input().split())
taste=[]
for i in range(n):
    taste.append(i+l)
taste.sort(key=abs)

print(sum(taste)-taste[0])
# Judge status: Accepted
def judge(S, N):
    if N % 2 != 0:
        return 'No'
    if S[:N//2] == S[N//2:]:
        return 'Yes'
    else:
        return 'No'


N = int(input())
S = input()
print(judge(S, N))
# Judge status: Accepted
import sys
def input(): return sys.stdin.readline().rstrip()


def main():
  N, K = map(int, input().split())

  a = N%K
  if a > abs(a-K):
    print(abs(a-K))
  else:
    print(a)

if __name__ == '__main__':
  main()
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))

B = [abs(i) for i in A]
minus = [int(i<0) for i in A]
if sum(minus)%2 == 0:
    print(sum(B))
else:
    print(sum(B)-2*min(B))
# Judge status: Accepted
C = input()
n = chr(ord(C)+1)
print(n)
# Judge status: Accepted
from collections import defaultdict
it = lambda: list(map(int, input().strip().split()))
INF = float('inf')

def solve():
    X, Y = it()
    if Y % 2:
        return False
    return 4 * X >= Y >= 2 * X

if __name__ == '__main__':
    if not solve():
        print('No')
    else:
        print('Yes')
# Judge status: Accepted
sArray = list(input().split())

result = ''
for i in sArray:
  result += ''.join(i[0])

print(result)
# Judge status: Accepted
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


def main():
    N = int(input())
    S = [int(input()) for _ in range(N)]

    S.sort()
    result = sum(S)

    if result % 10 == 0:
        for s in S:
            if s % 10:
                print(result - s)
                exit()
    else:
        print(result)
        exit()

    print(0)


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
n,k=map(int,input().split())
a=[int(x) for x in input().split()]
ans=1
n-=k
ans+=(n+k-1)//k
print(ans)
# Judge status: Wrong Answer
x,y=map(int,input().split())
if (x*10)%y != 0:
    print(x*10)
# Judge status: Accepted
s = input()
n = len(s)

s = "".join(reversed(list(s)))
while n:
    if s.startswith("maerd"):
        n -= 5
        s = s[5:]
    elif s.startswith("remaerd"):
        n -= 7
        s = s[7:]
    elif s.startswith("esare"):
        n -= 5
        s = s[5:]
    elif s.startswith("resare"):
        n -= 6
        s = s[6:]
    else:
        break
print("YES" if n == 0 else "NO")
# Judge status: Accepted
# coding: utf-8

def main():
    N = sorted(list(map(int, input().split())))
    ans = N[0] * N[1] * (N[2] % 2)
    print(ans)

if __name__ == "__main__":
    main()
# Judge status: Accepted
N = int(input())
s = str(N)
for i in range(len(s)):
    if s[i]=="9":
        print("Yes")
        exit()

print("No")
# Judge status: Wrong Answer
x=int(input())
y=19

ans=0
ans+=(x//11)*2
cnt=x%11
if cnt>=6:
  ans+=2
elif cnt>=1:
  ans+=1
  
print(ans)
# Judge status: Accepted
H = int(input())

def calc(X):
  if X==1:
    return 1
  else:
    return 1+2*calc(X//2)
  
print(calc(H))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

A = [A[i - 1] - i for i in range(1, N + 1)]

A.sort()
med = A[N // 2 - 1]
A = [abs(A[i - 1] - med) for i in range(1, N + 1)]

print(sum(A))
# Judge status: Accepted
n, k, s = map(int, input().split())
if s == 1:
    ans = [s+1] * n
else:
    ans = [s-1] * n

for i in range(k):
    ans[i] = s
print(' '.join(map(lambda x: str(x), ans)))
# Judge status: Accepted
w, a, b = map(int, input().split())
print(abs(b - a) - w if abs(b - a) > w >= 0 else 0)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

ans = 10**8 
sum_A = sum(A)
hoge = 0


for i in range(N-1):
  hoge = hoge + A[i]
  ans = min(ans,(abs((sum_A - hoge)-(hoge))))

print(ans)
# Judge status: Accepted
def main():
    N,X,Y = [int(n) for n in input().split()]
    X -= 1
    Y -= 1
    res = [0] * N
    for i in range(N):
        for j in range(i,N):
            dis = min([j - i, abs(i - X) + 1 + abs(j-Y), abs(i - Y) + 1 + abs(j-Y)])
            # print(i,j,X,Y)
            # print(dis)
            res[dis]+=1
    for i in range(1,N):
        print(res[i])
main()
# Judge status: Accepted
import sys
input = sys.stdin.readline

'''

'''

n = int(input())
a = sorted(map(int, input().split()))
largest = a[-1]
#largest = arr[-1]
div = [1] * (largest+1)
count = 0
arr = []
# remove duplicates
for i, v in enumerate(a):
    if i < (n-1) and a[i+1] == v:
        div[v] = 0
    else:
        arr.append(v)

for num in arr:
    if div[num]:
        count += 1

    for d in range(num, largest+1, num):
        div[d] = 0

print(count)
# Judge status: Wrong Answer
N = int(input())
A = [int(input()) for i in range(N)]


sorted_A = list(reversed(sorted(A)))

maxiuam = sorted_A[0]

is_there_tow_maximum = A.count(maxiuam) >= 2
if is_there_tow_maximum:
    answer = str(maxiuam) * (N - 1)
    print(answer)

second = None
for Ai in sorted_A:
    if Ai < maxiuam:
        second = Ai
        break

answer = []
for Ai in A:
    if Ai == maxiuam:
        answer.append(second)
    else:
        answer.append(maxiuam)
answer = "\n".join(map(str, answer))

print(answer)
# Judge status: Wrong Answer
import math
a,b,c=map(int,input().split())
if math.sqrt(a)+math.sqrt(b)<math.sqrt(c):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
#!python3

# input
N = int(input())

MOD = 10 ** 9 + 7


def main():
    x = 1
    for i in range(1, N + 1):
        x = x * i % MOD
    print(x)


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
n = list(input())
x = len(n)
ans = 0

for i in range(x):
    t = int(n[i])
    if t < 6:
        ans += t
    else:
        ans += 10 - t

if n[-1] != "0":
    ans += 1
print(ans)
# Judge status: Wrong Answer
from sys import stdin, stdout
from time import perf_counter

import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7

n, x = map(int,input().split())
# print(n,x)

a = list(map(int, input().split()))
# print(a)

temp = 0
if x>0:
    for i in range(1,n):
        if a[i-1] + a[i]>x:
            
            temp+= (a[i-1] + a[i]) - x
            a[i]=0
        else:
            continue
    print(temp)
else:
    print(a[0]+a[1])
# Judge status: Accepted
def func(x1,y1,x2,y2):
    return abs(x1-x2)+abs(y1-y2)
n,m = map(int,input().split())
g = [list(map(int,input().split())) for _ in range(n)]
c = [list(map(int,input().split())) for _ in range(m)]
index = 0
for k in g:
    num = 10**9
    for i,d in enumerate(c):
        tmp = func(k[0],k[1],d[0],d[1])
        if tmp < num:
            num = tmp
            index = i
    print(index+1)
# Judge status: Wrong Answer
import collections as cl
N = int(input())
A = list(map(int,input().split()))
cn = cl.Counter(A)
sumC = sum([N*(N-1)//2 for N in cn.values()])
for k in range(N):
  sum = sumC - cn[A[k]] +1
print(sum)
# Judge status: Wrong Answer

#ライブラリインポート
from collections import defaultdict

con = 10 ** 9 + 7
#入力受け取り
def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	S = input()
	N = len(S)
	judge = "Yes"
	s = int((N - 3) // 2)
	t = int((N + 1) // 2)
	for i in range(int((N - 1) // 2)):
		if S[i] != S[s - i]:
			judge = "No"
		if S[t + i] != S[N - 1 - i]:
			judge = "No"

	print(judge)

if __name__ == '__main__':
	main()
# Judge status: Wrong Answer
n,k = map(int,input().split())
a = list(map(int,input().split()))

if(len(set(a)) <= k):
    print(0)
else:
    dic_a = {x:0 for x in set(a)}
    for i in a:
        dic_a[i] += 1
    sum = 0
    a = sorted(dic_a.items(), key=lambda x: x[0])
    for i in range(k,len(a)):
        sum += a[i][1]
    print(sum)
# Judge status: Accepted
A,B,C=map(int,input().split())
if (A<=C<=B):
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n=int(input())
s=str(input())
ans=0

for i in range(n-1):
    n=i+1
    if s[n]=='E':
        ans=ans+1

cnt=ans

for i in range(n):
    if s[i:i+2]=='WW':
        cnt=cnt+1
    elif s[i:i+2]=='EE':
        cnt=cnt-1
    else:
        0
        
    #print('i,s[i:i+2],ans,cnt',i,s[i:i+2],ans,cnt)
    ans=min(ans,cnt)
print(ans)
# Judge status: Accepted
n=int(input())
p=[int(i) for i in input().split()]

count=0
for i in range(1,n-1):
    if (p[i-1]<p[i]<p[i+1]) or p[i+1]<p[i]<p[i-1]:
        count+=1
print(count)
# Judge status: Accepted
def two_int():
    N, K = map(int, input().split())
    return N,K

def one_int():
    return int(input())

def one_str():
    return input()

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

l = many_int()
K=one_int()

M=max(l)

l.remove(M)

print(M*(2**K)+sum(l))
# Judge status: Accepted
from fractions import gcd
from functools import reduce


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


def solve(string):
    n, m, *a = map(int, string.split())
    c = 2**len(bin(a[0]).split("1")[-1])
    l = reduce(lcm, (2 * m + 2 if _a % c or not _a // c % 2 else _a for _a in a))
    return str(max((m - l // 2) // l + 1, 0))


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))
# Judge status: Accepted
n,k=map(int,input().split())
arr=list(map(int,input().split()))
def isvalid(mid,k):
    if mid==0:
        return False
    ans=k
    for i in arr:
        if i>mid:
            ans-=i//mid
    return ans>=0


l=0
r=10**9
while(l<r):
    mid=(l+r)//2
    if isvalid(mid,k):
        r=mid
    else:
        l=mid+1
print(l)
# Judge status: Accepted
a,b,h = [int(input()) for i in range(3)]
print((a+b)*h//2)
# Judge status: Wrong Answer
x = int(input())
for i in range(200):
  for j in range(-200,200):
    if(i**5-j**5==x):
      print(i,j)
      break
# Judge status: Accepted
def resolve():
    N, X, T = map(int,input().split())
    turn = N//X
    if N%X == 0:
        print(turn*T)
    else:
        print((turn+1)*T)
resolve()
# Judge status: Wrong Answer
n, x = map(int, input().split())

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

dis = list(map(lambda f: abs(f-x), xlist))
print(min(dis))
# Judge status: Accepted
from math import *
from statistics import median
N=int(input())
A,B=[],[]
for i in range(N):
    a,b=map(int,input().split())
    A.append(a);B.append(b)
A.sort();B.sort()
if N%2:
    ans=median(B)-median(A)+1
else:
    ans=(median(B)-median(A))*2+1
print(int(ans))
# Judge status: Wrong Answer
A,B,K=map(int,input().split())
check = 0
res = 0
for i in range(1,100):
  if A % i == 0 and B % i == 0:
    check += 1
    if check == K:
      res = i
      break
print(res)
# Judge status: Accepted
a, b = map(int, input().split())
 
if (a - b) % 2 == 0:
  r = int(abs(a - b)/2 + min(a, b))
else:
  r = 'IMPOSSIBLE'
print(r)
# Judge status: Accepted
S=input()
print(2*min(S.count('1'),S.count('0')))
# Judge status: Accepted
x, y = map(int, input().split())
minusx = x * -1
minusy = y * -1
a = [0]*4
a[0] = y - x
a[1] = y - minusx + 1
a[2] = minusy - x + 1
a[3] = minusy - minusx + 2
ans = 1001001001
for i in a:
    if i < 0:
        pass
    else:
        ans = min(ans,i)

print(ans)
# Judge status: Accepted
n = int(input())
ans = 0
for i in range(26):
    for j in range(26):
        if 4 * i + 7 * j == n:
            ans += 1
if ans == 0:
    print('No')
else:
    print('Yes')
# Judge status: Accepted
def main():
    n = int(input())
    h = list(map(int, input().split()))
    maxv = 0
    cnt = 0
    for i in range(n-1):
        if h[i+1] <= h[i]:
            cnt += 1
        else:
            maxv = max(maxv, cnt)
            cnt = 0    
    maxv = max(maxv, cnt)
    print(maxv)
     
if __name__ == '__main__':
    main()
# Judge status: Accepted
N = int(input())

d = {}
ans = 0

for i in range(N):
    a = int(input())
    if a not in d:
        d[a] = 1
    else:
        d[a] += 1

for v in d.values():
    if v % 2 == 1:
        ans += 1

print(ans)
# Judge status: Accepted
a = list(map(int,input().split()))
n = int(input())
d = a[3]
s = min(a[2],a[1]*2,a[0]*4)
mi = min(s*2,d)
if n%2 == 0:
    if mi == s*2:
        print(n//2*2*s)
    else:
        print(n//2*d)
else:
    if mi == s*2:
        print(n*s)
    else:
        print(n//2*d+s)
# Judge status: Wrong Answer
n=int(input())
s=input()
ans=0
x=0
for i in range(n):
    x=max(0,ans)
    if s[i]=='I':
        ans+=1
    else:
        ans-=1
print(x)
# Judge status: Accepted
n=int(input())

cnt=0
for i in range(1,n):
    cnt +=(n-1)//i
print(cnt)
# Judge status: Accepted
'''
Created on 2020/08/19

@author: harurun
'''
def main():
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write

  a,b=map(int,pin().split())
  if a<0 and b<0:
    if (abs(b-a)+1)%2==0:
      print("Positive")
    else:
      print("Negative")
  elif a>0 and b>0:
    print("Positive")
  else :
    print("Zero")
  return

main()
# Judge status: Accepted
import sys
import os

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    X, A, B = list(map(int, sys.stdin.buffer.readline().decode().split()))
    if B - A > X:
        print('dangerous')
    elif A >= B:
        print('delicious')
    else:
        print('safe')


if __name__ == '__main__':
    main()
# Judge status: Accepted
N = int(input())
S = [input() for _ in range(N)]

alp = [chr(i) for i in range(97,123)]

ans = ""
for al in alp :
    count = 10**10
    for sen in S :
        count = min(count, sen.count(al))
    ans += al * count

print(ans)
# Judge status: Wrong Answer
n = int(input())
na = []
cou = []
count = 0
for i in range(n):
    a = int(input())
    na.append(a)
for j in range(n):
    if na[j] in cou:
        count -= 1
    else:
        count += 1
        cou.append(na[j])
print(count)
# Judge status: Accepted
N=int(input())
S=input()
s=""
m=""
ss=[]
mm=[]
s1=set()
m1=set()
res = 0
for i in range(N):
  s=S[0:i+1]
  m=S[i+1:N]
  ss=list(s)
  mm=list(m)
  s1=set(ss)
  m1=set(mm)
  s_intersection = s1 & m1
  res= max(res,len(s_intersection))
print(res)
# Judge status: Wrong Answer
# -*- coding: utf-8 -*-
import sys
from collections import deque, defaultdict
from math import sqrt, factorial, gcd
# def input(): return sys.stdin.readline()[:-1] # warning not \n
# def input(): return sys.stdin.buffer.readline().strip() # warning bytes
# def input(): return sys.stdin.buffer.readline().decode('utf-8')


def solve():
    # n, m = [int(x) for x in input().split()]
    n = int(input()) * 10
    if n == 60:
        print(1)
    else:
        print((n + 54) // 55)
    
    
t = 1
# t = int(input())
for case in range(1,t+1):
    ans = solve()


"""

R s
S p
P r

"""
# Judge status: Accepted
N, M = map(int, input().split())
H = list(map(int, input().split()))

A = [0]*M
B = [0]*M
for i in range(M):
    ta, tb = map(int, input().split())
    A[i] = ta - 1
    B[i] = tb - 1

ans = [True]*N
# v: Trueならいい展望台、Falseなら良くない展望台 
for i in range(M):
    ans[A[i]] = H[A[i]] > H[B[i]] and ans[A[i]]
    ans[B[i]] = H[B[i]] > H[A[i]] and ans[B[i]]

print(ans.count(True))
# Judge status: Accepted
*X, = map(int, input().split())
print(X.index(0) + 1)
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))

cnt = 0
for i in range(N-1,-1,-1):
  t = min(A[i+1],B[i])
  A[i+1] -= t
  B[i] -= t
  cnt += t
  t = min(A[i],B[i])
  A[i] -= t
  B[i] -= t
  cnt += t
  
print(cnt)
# Judge status: Wrong Answer
N,M,*X = map(int, open(0).read().split())
X.sort()
D = [abs(X[i+1] - X[i]) for i in range(M-1)]
if N >= M:
    print(X[-1] - X[0] - sum(sorted(D)[-(N-1):][::-1]))
else:
    print(0)
# Judge status: Accepted
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
# debug = lambda *a, **kw: print(*a, **kw, file=sys.stderr)

x = inl()


def solve():
    for i, y in enumerate(x):
        if y != i + 1:
            return i + 1
    return None


print(solve())
# Judge status: Wrong Answer
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))

# 最小値付近から攻める
idx = a.index(min(a))
right = n - idx - 1
left = idx

q1,r1 = divmod(left, k-1)
q2,r2 = divmod(right, k-1)
print(q1, q2, r1, r2)
print(q1 + q2 + min(r1,1) + min(r2,1))
# Judge status: Wrong Answer
n, m = map(int, input().split())
print( (n * 2 + m) // 4)
# Judge status: Accepted
import math
N, = (int(x) for x in input().split())

sol = 0
for i in range(1, N+1):
    for j in range(1, N + 1):
        G = math.gcd(i, j)
        if G == 1:
            sol += N
            continue
        for k in range(1, N + 1):
            g = math.gcd(G, k)
            sol += g
print(sol)
# Judge status: Accepted
n = int(input())
m = n + 1
sum = 0
if m <= 3:
  for x in range(m):
    sum = sum + x
else:
  for x in range(m):
    if x%3 == 0 or x%5 == 0:
      pass
    else:
      sum = sum + x
print(sum)
# Judge status: Wrong Answer
s = input()

if s[2]==s[3] and s[4]==s[5]:
  print("yes")
else:
  print("no")
# Judge status: Wrong Answer
n=int(input())
s=input()
if n>1:
  a=s[0:int(n/2)]
  b=s[int(n/2):]
  c=0
  for i in range(int(len(s)/2)):
    if a[i]==b[i]:
      c=c+1
    else:
        pass
  if c==int(n/2):
    print('Yes')
  else:
    print('No')
else:
  print('No')
# Judge status: Accepted
K, X = map(int, input().split())

def check():
    if 500*K>=X:
        return 'Yes'
    return 'No'
print(check())
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))

L={}
R={}
for i in range(1,len(A)+1):
  L[str(i+A[i-1])] = L.get(str(i+A[i-1]),0)+1
  R[str(i-A[i-1])] = R.get(str(i-A[i-1]),0)+1

ans = 0
for i in range(1,N+1):
  if str(i) in L and str(i) in R:
    ans += L[str(i)] * R[str(i)]

print(ans)