peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
#-------------
X = int(input())
#-------------

if X >= 30 :
  print("Yes")
else:
  print("No")
# Judge status: Accepted
w = str(input())
check = int(0)
c = int(0)

for a in [chr(i) for i in range(97,97+26)]:
  c = w.count(a)
#  print(str(w)+"チェック"+str(a))
  if(c%2 == 1):
    check = check + 1

if(check == 0):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
def tax_increase(a,b):
    t8  = 0.08
    t10 = 0.1
    for i in range(b*10,(b+1)*10,1):
        if int(i*t8) == a:
            return i
    return -1
    
if __name__ == '__main__':
    a,b = map(int,input().split())
    ans = int(tax_increase(a,b))
    print(ans)
# Judge status: Accepted
N, K = list(map(int, input().split()))
val = 1
num = 0
ans = 0

x = 1
while x < K:
    x = 2 * x

for i in range(N):
    target = N - i
    tmp = val
    while tmp * target < K:
        num += 1
        tmp = 2 * tmp
    val = tmp
    ans += x // tmp
print('{:.10g}'.format(ans / (N * x)))
# Judge status: Accepted
from collections import Counter
n = int(input())
S = Counter([input() for i in range(n)])
m = int(input())
T = Counter([input() for i in range(m)])

ans = 0
for k, v in S.items():
    tmp = v
    if k in T:
        tmp -= T[k]
    ans = max(ans, tmp)
            
print(ans)
# Judge status: Accepted
n=int(input())
s=input()
x=[0]
for i in s:
    if i=="I":
        x.append(x[-1]+1)
    else:
        x.append(x[-1]-1)
print(max(x))
# Judge status: Accepted
L, R = map(int, input().split())

ans = 10**9
for i in range(L, min(R, L+2019)+1):
    for j in range(i+1, min(R, L+2019)+1):
        ans = min(ans, (i % 2019) * (j % 2019) % 2019)

print(ans)
# Judge status: Accepted
S,C = list(map(int,input().split()))

if 2*S > C:
    ans = C//2
else:
    ans = S+(C-2*S)//4
    
print(ans)
# Judge status: Wrong Answer
n,m=map(int,input().split())
A=[input() for i in range(n)]
B=[input() for i in range(m)]
R=range(n-m+1)

for i in R:
  for j in R:
    for k in range(m):
      if A[j+k][i:i+m]!=B[k]:
        break
      else:
        print("Yes")
        exit()

print("No")
# Judge status: Accepted
n, k = map(int,input().split())
r, s, p = map(int,input().split())
t = [i for i in input()]
ans = 0
for i in range(n):
    if t[i] == 'r':
        tmp = p
        ans += p
    elif t[i] == 's':
        tmp = r
        ans += r
    elif t[i] == 'p':
        tmp = s
        ans += s
    if k <= i and t[i-k] == t[i]:
        ans -= tmp
        t[i] = 'X'
print(ans)
# Judge status: Wrong Answer
n=int(input())
a=int(input())

if a <= n or (500<=a and a<=500+n):
  print('Yes')
else:
  print('No')
# Judge status: Accepted
# うしろから確定していく（前のやつはうしろのやつをいじれない）のでうしろからみていく。
N = int(input())
a, b = [], []
for _ in range(N):
    ai, bi = map(int, input().split())
    a.append(ai)
    b.append(bi)
a = a[::-1]
b = b[::-1]
cur = 0

for i in range(N):
    if (a[i] + cur) % b[i] == 0:
        continue
    tmp = b[i] * ((a[i] + cur) // b[i] + 1) - (a[i] + cur)
    cur += tmp

print(cur)
# Judge status: Accepted
from itertools import permutations
n = int(input())
x = ''.join([str(i) for i in range(1,  n + 1)])
p = tuple(input().split())
q = tuple(input().split())
pers = list(permutations(x, n))
pers.sort()
print(abs(pers.index(p) - pers.index(q)))
# Judge status: Accepted
n,k=map(int,input().split())
h=[int(input()) for i in range(n)]
h.sort()
ans=[]
for i in range(n-k+1):
    ans.append(h[i+k-1]-h[i])
print(min(ans))
# Judge status: Accepted
n, m = map(int, input().split())

for i in reversed(range(1, m//n + 1)):
    if m % i == 0:
        print(i)
        break
# Judge status: Wrong Answer
A, B, C, K = map(int, input().split())

if A == B == C:
    print(0)
else:  
    for _ in range(K):
        a = B + C
        b = A + C
        c = A + C
        A = a
        B = b
        C = c

    if A - B > 10e18:
        print('Unfair')
    else:
        print(A)
# Judge status: Wrong Answer
n,k = map(int,input().split())
li = [int(input()) for _ in range(n)]
li.sort()
ans = 10**5
for i in range(n-k+1):
    ans = min(ans,li[i+k-1]-li[i])
print(ans)
# Judge status: Wrong Answer
def main():
    A,B,K = list(map(int,input().split()))

    c = K - A
    if(c >= 0):
        print(0,B-c)
    else:
        print(A-K,B)


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
from collections import Counter

N = int(input())
s = [input() for _ in range(N)]

# N=10^5より、O(N)で解く
for i in range(N):
  s[i] = Counter(s[i]).most_common()
# Judge status: Accepted
n = int(input())
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
ans = 0
for i in range(n):
    ans =max(sum(a1[0:i+1])+sum(a2[i:n]),ans)
print(ans)
# Judge status: Accepted
def f(n):
    mod = 1000000007
    return (pow(10, n, mod) - 2 * pow(9, n, mod) + pow(8, n, mod)) % mod

n = int(input())
print(f(n))
# Judge status: Accepted
x,y = map(int,input().split())
i = 1
while x *(2 ** i) <= y:
    i += 1

print(i)
# Judge status: Accepted
N = int(input())
K = int(input())
X = int(input())
Y = int(input())
s = 0
for i in range(1, N+1):
    if i <= K:
        s += X
    else:
        s += Y
print(s)
# Judge status: Accepted
q, h, s, d = map(int, input().split())
n = int(input())
l = min(q * 8, h * 4, s * 2, d)
if n % 2 == 0:
    print(l * n // 2)
else:
    if l == d:
        l2 = min(q * 4, h * 2, s)
        print(n // 2 * l + l2)
    else:
        print(l * n // 2)
# Judge status: Wrong Answer
n = input()
a = int(n[:1])+1
ans = a*1000-int(n)
if(ans == 1000):
    print(0)
elif ans>1000:
    print(1000-int(n))
else:
    print(ans)
# Judge status: Accepted
s = input()
l = -1
r = -1
for i in range(len(s)):
    if s[i] == 'A' and l == -1:
        l = i
    elif s[i] == 'Z':
        r = i
print(r-l+1)
# Judge status: Wrong Answer
import math

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

m = sum(li) / N

new = sorted(li)

for i in range(N):
  if li[i] < m:
    print(new[math.floor(N/2+1) - 1])
  else:
    print(new[math.floor(N/2-1)])
# Judge status: Accepted
S = input()

result = "Good"
for i in range(1, len(S)):
    if S[i] == S[i-1]:
        result = "Bad"
        break
print(result)
# Judge status: Accepted
N=int(input())
import math
A=list(map(int,input().split()))
b=math.ceil(math.log(max(max(A),1),2)) 
B=[0 for i in range(b)] #0のリスト
C=[0 for i in range(b)] #1のリスト
for i in A:
  for j in range(b):
    if ((i>>j) & 1):
      C[j]+=1
    else:
      B[j]+=1
 # print(B,C,i)
mod =10**9+7
ans=[(B[i]*C[i])*2**i % mod for i in range(b)]
print(sum(ans)%mod)
# Judge status: Accepted
N = int(input())

if N < 10:
    print(N)
    exit()

n = N - int((len(str(N)) - 1) * '9')
tmp = (len(str(N)) - 1) * '9'
if len(str(n)) > (len(str(N)) - 1):
    tmp = str(n)[0] + tmp

res = 0
for t in tmp:
    res += int(t)

print(res)
# Judge status: Accepted
n, a, b = map(int,input().split())

ans = 0
for i in range(n+1):
    i = str(i)
    k = 0
    for j in range(len(i)):
        k += int(i[j])
    if k <= b and k >= a:
        ans += int(i)

print(ans)
# Judge status: Wrong Answer
n,m=map(int,input().split())
f=list(map(int,input().split()))
f.remove(f[0])
for i in range(n-1):
    a=list(map(int,input().split()))
    a.remove(a[0])
    for j in f:
        if j  not in a:
            f.remove(j)
print(len(f))
# Judge status: Accepted
n, k = map(int, input().split())
l = [1] * n
for _ in range(k):
    d = int(input())
    for i in map(int, input().split()):
        l[i - 1] = 0
print(sum(l))
# Judge status: Accepted
from collections import deque
sa = input()
sb = input()
sc = input()

q = deque(sa[0])
sa = sa[1:]
while q:
  t = q.pop()
  if t == "a":
    if not sa:
      ans = "A"
      break
    q.append(sa[0])
    sa = sa[1:]
  elif t == "b":
    if not sb:
      ans = "B"
      break
    q.append(sb[0])
    sb = sb[1:]
  elif t == "c":
    if not sc:
      ans = "C"
      break
    q.append(sc[0])
    sc = sc[1:]
print(ans)
# Judge status: Accepted
def groupby(a):
    a2=[[a[0],1]]
    for i in range(1,len(a)):
        if a2[-1][0]==a[i]:
            a2[-1][1]+=1
        else:
            a2.append([a[i],1])
    return a2
w=list(input())
w.sort()
w=groupby(w)
for i in w:
    if i[1]%2==1:
        print("No")
        break
else:
    print("Yes")
# Judge status: Accepted
n,k = map(int,input().split())
lst = list(map(int,input().split()))

id_of_one = lst.index(1) #リスト内の最小値1のインデックスを取得

left = len(lst[0:id_of_one]) #1より左側にある数列の長さ
right = len(lst[id_of_one+1:]) #1より右側にある数列の長さ
total = left + right





counter = 0
while total > 0:
    counter += 1
    total -= k - 1

print(counter)
# Judge status: Wrong Answer
A, B, N = map(int,input().split())
ans = []

if N >= 100000:
    for i in range(N-500,N+1): 
        k = (A*i)//B - A*(i//B)
        ans.append(k)
        i = i + 1
    
else:
    for i in range(N//2,N+1):
        k = (A*i)//B - A*(i//B)
        ans.append(k)
        i = i + 1
    
print(max(ans))
# Judge status: Accepted
n,m=map(int,input().split())
if m<=1:
    if n<=1:
        print(0)
    else:
        print(n*(n-1)//2)
else:
    print((n*(n-1)//2)+(m*(m-1)//2))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

ans = 0
for a in A:
    ans ^= a
print(ans)
for a in A:
  	print(ans^a)
# Judge status: Accepted
n, q = map(int, input().split())
s = input()
d = [0]
for i in range(1, len(s)):
    d.append(d[-1] + (s[i-1:i+1] == 'AC'))
for _ in range(q):
    l, r = map(lambda x: int(x) - 1, input().split())
    if s[l] == 'C':
        l += 1
    print(d[r] - d[l])
# Judge status: Accepted
a,b = map(int, input().split())
ans = (1+(b-a))*(b-a)/2 - b
print(int(ans))
# Judge status: Wrong Answer
n = int(input())
 
numbers = list(map(int, input().split(' ')))
approved = False
 
for num in numbers[1::2]:
  if (num % 3 == 0) or (num % 5 == 0):
    approved = True
    continue
  else:
    approved = False
    print('DENIED')
    break
if approved:
  print('APPROVED')
# Judge status: Wrong Answer
def mapt(fn, *args):
  return tuple(map(fn, *args))


n, k = mapt(int, input().split(" "))
p = mapt(int, input().split(" "))
print(sum(sorted(p)[:3]))
# Judge status: Accepted
a,b,c=map(int,input().split())
ans = 10*b+c
ans %= 4
if ans == 0:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
N = int(input())
v = list(map(int,input().split()))

v.sort()

for i in range(N-1):
    v[i+1] = (v[i]+v[i+1])/2
    v[i] = 0

print(sum(v))
# Judge status: Accepted
S = input()
c1, c2 = 0, 0

for i, b in enumerate(S):
    b = int(b)
    if b != i%2:
        c1 += 1
    if b != (i+1)%2:
        c2 += 1

print(min(c1, c2))
# Judge status: Accepted
N=int(input())
d=[input().split() for i in range(N)]
name=[]
for i in range(N):
    d[i].append(i+1)
    d[i][1]=int(d[i][1])
    name.append(d[i][0])
Name=list(set(name))
Name.sort()
d.sort()
for i in range(len(Name)):
    li=[]
    for j in range(N):
        if Name[i]==d[j][0]:
            li.append([d[j][1],d[j][2]])
        else:
            continue
    li.sort()
    Li=li[::-1]
    for k in range(len(li)):
        print(Li[k][1])
# Judge status: Accepted
S = int(input())
p=(10**9)+7

ans_=[0,0,0]

N = 2000
for s in range(3,N+1):
#     print('===',s)
    a = 1
    s = s-3
    while s >= 0:
        if s < 0:
            break
        a += ans_[s]
#         print(s,a)
        s-=1
    ans_.append(a)

print(ans_[S]%p)
# Judge status: Accepted
N,D = (int(T) for T in input().split())
Count = 0
for NT in range(0,N):
    X,Y = (int(T) for T in input().split())
    if X**2+Y**2<=D**2:
        Count += 1
print(Count)
# Judge status: Wrong Answer
from math import factorial
def combinations_count(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

N, M = map(int, input().split())
mod = 10**9 + 7
print(((factorial(N) % mod) * (combinations_count(N + 1, M) % mod) * (factorial(M) % mod)) % mod if abs(N - M) <= 2 else 0)
# Judge status: Accepted
a = int(input())
b = input()

if a >= 3200:
  print(b)
else:
  print("red")
# Judge status: Accepted
N = int(input())
A = int(input())

tmp = N//500
N -= tmp * 500
if N <= A:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N = int(input())
W = [input() for _ in range(N)]
for i in range(N):
    for j in range(N):
        if i != j:
            if W[i] == W[j]:
                print("No")
                exit()
for k in range(N-1):
    if W[k][-1] != W[k+1][0]:
        print("No")
        exit()
print("Yes")
# Judge status: Wrong Answer
n =int(input())
a=[]
b=[]
c=[]
a =list(map(int,input().split()))
a.sort()
b =list(map(int,input().split()))
b.sort()
c =list(map(int,input().split()))
c.sort()
b_limit = 0
count =0

for i in a:
    if b_limit == 1:
        break
    for j in  reversed(b):
        if j <= i:
            b_limit +=1
            break
        for k in reversed(c):
            if k <= j:
                break
            count +=1

print(count)
# Judge status: Wrong Answer
L=list(map(int,input().split()))
K=int(input())
N=sorted(L)
print(N[0]+N[1]+N[2]*2*K)
# Judge status: Accepted
def main():
    N = int(input())
    A = map(int, input().split(" "))
    list = [""] * (N + 1)
    for i, a in enumerate(A, 1):
        list[a] = str(i)
    print(" ".join(list[1:]))


if __name__ == '__main__':
    main()
# Judge status: Accepted
def factorial(n, mod=10**9 + 7):
    a = 1
    for i in range(1, n + 1):
        a = a * i % mod
    return a


def main():
    N, M = map(int, input().split())
    mod = 10 ** 9 + 7
    if abs(N - M) > 1:
        ans = 0
    elif abs(N - M) == 1:
        ans = (factorial(min(N, M))**2 * max(N, M)) % mod
    else:
        ans = (factorial(N)**2 * 2) % mod

    print(ans)


if __name__ == "__main__":
    main()
# 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()

bc = [0]*n
bc[n-1]=n-bisect.bisect_right(c, b[n-1])

for i in range(0,n-1):
  bc[n-2-i]=bc[n-1-i] + n-bisect.bisect_right(c, b[n-2-i])

ans = 0
for i in range(n):
  temp = bisect.bisect_right(b, a[i])
  if temp != n:  
    ans += bc[temp]
  
print(ans)
# Judge status: Wrong Answer
s=input()
t=input()
l=len(t)-1
if l==len(s) and s==t[0:l]:
  print("YES")
else:
  print("NO")
# Judge status: Accepted
n = int(input())
P = tuple(map(lambda x: int(x)-1, input().split()))
ans = 0
pre = P[0]
for i in range(n-1):
    if pre == i:
        ans += 1
    else:
        pre = P[i+1]
if pre == n-1:
    ans += 1
print(ans)
# Judge status: Accepted
import sys

def main():
    N = int(sys.stdin.readline().rstrip())

    cnt = 0
    ans = "No"
    for i in range(N):
        a,b = map(int, sys.stdin.readline().rstrip().split())
        if a == b:
            cnt += 1
        else:
            cnt =0
        
        if cnt == 3:
            ans = "Yes"

    print(ans)


main()
# Judge status: Accepted
from collections import defaultdict
n = int(input())
dd = defaultdict(int)
for i in range(n):
  s = int(input())
  dd[s]+=1
res = 0
for i in dd.keys():
  if dd[i]%2:
    res+=1
print(res)
# Judge status: Accepted
n,a,b = map(int,input().split())
if (b-a)%2 == 0:
    print((b-a)//2)
else:
    print(min(a,n-b+1)+(b-a-1)//2)
# Judge status: Wrong Answer
import sys 

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



if N == 1:
    print(A[0])
    sys.exit()

mae = []
usiro = []

#0の時に前 1の時に後ろ
Flag = 0

for i in reversed(range(0,N,1)):
    
    if Flag == 0: # 前の時
        mae.append(str(A[i]))
        mae.append(" ")
        Flag = 1
    else:
        usiro.insert(0,str(A[i]))
        Flag = 0

moziretu = (mae + usiro)
moziretu = ''.join(moziretu)

print(''.join(moziretu))
# Judge status: Accepted
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")

s = input()
d = {"SUN": 7, "MON": 6, "TUE": 5,"WED": 4, "THU": 3,"FRI":2,"SAT":1}
print(d[s])
# Judge status: Accepted
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
if b/a>=c:
  print(c)
else:
  print(int(b/a))
# Judge status: Accepted
from collections import defaultdict

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

ball_count=[1 for _ in range(N)]
redExist=[0 for _ in range(N)]
redExist[0]=1
for m in range(M):
  x, y = map(int, input().split())
  #1オリジンから0オリジンに
  x-=1
  y-=1

  ball_count[x] -= 1
  ball_count[y] += 1
  if (redExist[x]):
    redExist[y]=True
  if ball_count[x] == 0:
    redExist[x]=False
print(len([b for b in redExist if b]))
# Judge status: Accepted
A,B,X=map(int,input().split())
if X>A+B:
    print("NO")
elif A>X:
    print("NO")
else:
    print("YES")
# Judge status: Accepted
spam = input()
if spam == spam.upper():
    print('A')
else:
    print('a')
# Judge status: Accepted
A = list(map(int, input().split()))

A.sort()

if A == [5, 5, 7]:
  print("YES")
else:
  print("NO")
# Judge status: Accepted
h1, m1, h2, m2, k = map(int, input().split())

st = h1 * 60 + m1
en = h2 * 60 + m2

print(max(0, en - st - k))
# Judge status: Wrong Answer
import collections
N, M = map(int, input().split())

num = []
for i in range(M):
    a, b = map(int, input().split())
    num.append(a)
    num.append(b)
    
num.sort()
count = collections.Counter(num)
countkey = list(count.keys())
for i in countkey:
    print(count[i])
# Judge status: Wrong Answer
# ans

import sys
input = sys.stdin.readline
N = int(input())
d = list(map(int, input().split()))
d.sort()

print(d[N//2] - (d[N//2] - 1))
# Judge status: Accepted
s = int(input())

v = 10**9
x = (v - s % v) % v
y = (s + x) // (10**9)

print('0 0 1000000000 1', x, y)
# Judge status: Accepted
n = int(input())
dic = {}
for i in range(n):
    w = input()
    if dic.get(w) is None:
        dic[w] = 1
    else:
        dic[w] += 1

ans = sorted(dic.items(), key=lambda x:x[1],reverse=True)

maxn = ans[0][1]

ans = [x for x,y in ans if maxn==y]
ans.sort()
for i in ans:
    print(i)
# Judge status: Accepted
from collections import deque

n, m = map(int, input().split())
eg = [[] for _ in range(n + 1)]

for _ in range(m):
    a, b = map(int, input().split())
    eg[a].append(b)
    eg[b].append(a)

xs = [0] * (n + 1)
q = deque()
q.append(1)
seen = {1}
while len(q) > 0:
    v = q.popleft()
    for t in eg[v]:
        if t in seen:
            continue
        q.append(t)
        seen.add(t)
        xs[t] = v
print("Yes")
print(*xs[2:], sep="\n")
# Judge status: Accepted
S = input()
T = input()

rolled = S

ans = "No"

for _ in S:
    rolled = rolled[-1] + rolled[:-1]
    if rolled == T:
        ans = "Yes"
        break

print(ans)
# Judge status: Wrong Answer
x = int(input())
for i in range(-100,100):
    for j in range(-100,100):
        if i**5-j**5==x:
            print(i,j)
            exit()
# Judge status: Wrong Answer
a, b = list(map(int, input().split()))
if (a*b)//2 == 0:
    print("Even")
else:
    print("Odd")
# Judge status: Wrong Answer
n = int(input())
s = input()
if "#." not in s:
    print(0)
else:
    print(min(s.count("."), s.count("#")))
# Judge status: Accepted
a=input()
b=input()
ans=""
for i in range(len(a)):
    if len(b)==i:
        ans+=a[i]
        break
    ans+=a[i]+b[i]
print(ans)
# Judge status: Accepted
#!/usr/bin/env python3
s, w = map(int, input().split())
print("unsafe" if s<=w else "safe")
# Judge status: Accepted
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())

def inpl(): return list(map(int, sys.stdin.readline().split()))

def inpl_str(): return list(sys.stdin.readline().split())

k, s = inpl()
ans = 0
for x in range(k+1):
    for y in range(k+1):
        z = s - x - y
        if 0 <= z and z <=k:
            ans += 1
print(ans)
# Judge status: Accepted
S = int(input())
mod =1000000007


kjs = [1] * 2001
for i in range(1, 2001):
    kjs[i] = kjs[i-1] * i


def combination(n1, n2):
    return kjs[n1]//(kjs[n2] * kjs[n1-n2])


n = S//3

ans = 0
for i in range(1, n+1):
    x = S - 3*i
    ans += combination(x+i-1, min(x, i-1))
    ans %= mod

print(ans)
# Judge status: Wrong Answer

def main():
    x, y = map(int, input().split())
    print(abs((x // y + x % y) - (x // y)))


if __name__ == "__main__":
    main()
# Judge status: Accepted
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    H, N = map(int, readline().split())
    Magic = list(list(map(int, readline().split())) for _ in range(N))

    dp = [INF]*(H+1)
    dp[0] = 0
    for h in range(H):
        for damage, cost in Magic:
            next_index = min(h + damage, H)
            dp[next_index] = min(dp[next_index],dp[h]+cost)
    print(dp[-1])

if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n = int(input())

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


highest = 0
diff = 0

a = a[::-1]

for i in a:
    if i > highest:
        highest = i
    diff = max(highest - i, diff)

print(diff)
# Judge status: Accepted
A, B = map(int, input().split())
if A>8 or B>8:
    print(':(')
else:
    print('Yay!')
# Judge status: Accepted
from collections import defaultdict
import math
N = int(input())
ps = defaultdict(int)
for i in range(2, int(math.sqrt(N))+1):
    while N % i == 0:  
        ps[i] += 1
        N //= i
    i += 1
if N > 1:
    ps[N] += 1
ans = 0
for p in ps:
    k = 1
    while ps[p] >= k:
        ans += 1
        ps[p] -= k
        k += 1
print(ans)
# Judge status: Accepted
n, a, b = map(int, [_ for _ in input().split()])
ans = 0
for i in range(n+1):
    cnt = 0
    for j in str(i):
        cnt += int(j)
    if a <= cnt <= b:
        ans += i
print(ans)
# Judge status: Wrong Answer
n,k = map(int,input().split())
arr = list(map(int,input().split()))

pro = 0
for i in range(k):
    pro += arr[i]


ans = pro
for i in range(k,n):
    pro = pro + arr[i]-arr[i-k]
    if arr[i-k] < arr[i]:
        ans = pro

print("{:.12g}".format((ans+k)/2))
# Judge status: Wrong Answer
import itertools
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
permu_list = itertools.permutations(range(N))
ans=0
c = 0
for p in permu_list:
  c += 1
  for i in range(1,N):
    ans += ((A[i-1][0]-A[i][0])**2+(A[i-1][1]-A[i][1])**2)**0.5
print(ans/c)
# Judge status: Accepted
s=input()
n=int(input())
r=-1
f=[]
b=[]
for i in range(n):
    q=input().split()
    if q[0]=='1':
        r*=-1
    else:
        t=int(q[1])
        if t*r==-1 or t*r==2 :
            f.append(q[2])
        else:
            b.append(q[2])
f=''.join(f)
b=''.join(b)
s=f[::-1]+s+b
if r==1:
    s=s[::-1]
print(s)
# Judge status: Wrong Answer
from fractions import gcd

N, M = map(int, input().split())
X = sorted(map(int, input().split()))

if N == 1:
    print(X[0] - N)
    exit()

ans = X[1] - X[0]
for i in range(N-1):
    ans = gcd(ans, X[i+1] - X[i])

print(ans)
# Judge status: Wrong Answer
N = int(input())

if (N <= 3):
    ans = 'No'
else:
    mod_7 = N % 7
    
    ans = 'No'
    
    for i in range(mod_7 + 1):
        n = N
        n -= 7 * i
        
        if (n % 4 == 0):
            ans = 'Yes'
            break

print(ans)
# Judge status: Wrong Answer
a, b, c = map(int, input().split())

h = (a + b + c) // 2

if h == a or h == b or h == c:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
a=int(input())
b=int(input())
c=int(input())
x=int(input())
cnt=0
for i in range(a+1):
	for j in range(b+1):
		for k in range(c+1):
			if 500*i+100*j+50*k==x:
				cnt += 1
print(cnt)
# Judge status: Accepted
N,M = [int(a) for a in input().split()]

a1 = min(N,M//2)
a2 = 0
if M//2 > N:
  a2 = (M - N*2)//4
  
a3 = a1+a2
print(a3)
# Judge status: Wrong Answer
a, b, c, k = map(int, input().split())

if k <= a:
    print(a)
elif k <= a + b:
    print(a)
else:
    print(a - (k - a - b))
# Judge status: Wrong Answer
D=int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
A = []
for i, c in enumerate(C):
    A.append((i, c))
A.sort(key=lambda x: x[1])
for i in range(D):
    j, c = A[i%26]
    print(j)
# Judge status: Accepted
s = input()
ans = 'None'
for i in range(97, 123):
    if chr(i) not in s:
        ans = chr(i)
        break
print(ans)