peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
s = str(input())
k = int(input())

n = len(s)

l = [0]*n
for i in range(n):
    l[i] = ord('z') -ord(s[i]) + 1
    l[i] %= 26
#print(l)

ans = list(s)
i = 0
while k > 0:
    if i > n-1:
        break
    if l[i] <= k:
        ans[i] = 'a'
        k -= l[i]
    i += 1
k %= 26
if k > 0:
    ans[-1] = chr((k + ord(ans[-1])-ord('a'))%26+97)
#print(ans)
print(''.join(ans))
# Judge status: Accepted
def solve(x):
    y = 100
    ans = 0
    while y < x:
        y = int(y * 1.01)
        ans += 1
    return ans

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

if S[-1] == "s":
    print(S+"es")
else:
    print(S+"s")
# Judge status: Accepted
n, m = map(int,input().split())
if n==0:
  c=m*(m-1)/2
elif m==0:
  c=n*(n-1)/2
else:
  c=n*(n-1)/2+m*(m-1)/2

print(int(c))
# Judge status: Accepted
import math
h = int(input())
if h == 1:
    print(1)
    exit()

x = 0
c = 1
while h >= 1:
    h = math.floor(h/2)
    x += c
    c *= 2

print(x)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))
a = list(set(a))
a.sort()
p = []

if len(a) == 1:
    print(0)
    exit()

for a_i in a:
    if not p:
        p.append(a_i)
        continue
    warikireru = False
    for p_i in p:
        if a_i%p_i == 0:
            warikireru = True
            break
    if warikireru:
        continue
    else:
        p.append(a_i)

print(len(p))
# Judge status: Wrong Answer
N = int(input())
A = list(map(int,input().split()))

cnt_2 = 0
cnt_4 = 0
for a in A:
  if a % 4 == 0:
    cnt_4 += 1
  elif a % 2 == 0:
    cnt_2 += 1
    
if N <= cnt_2 + cnt_4 * 3:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
import sys
from bisect import bisect
input = sys.stdin.readline

n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
b.sort()
c.sort()

bc = [0 for _ in range(n)]
for i in range(len(b)):
    if b[i] >= c[n-1]:
        break
    p = bisect(c,b[i])
    bc[i] = (n-p)

for i in range(len(b)-1,0,-1):
    bc[i-1] += bc[i]
ans = 0
for x in a:
    if x < b[n-1]:
        p = bisect(b,x)
        ans += bc[p]

print(ans)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int ,input().split()))
d = min(a)-len(a) - len(a)
u = max(a) * 2

while u-d > 1:
    mid = (d + u) // 2
    val = 0
    for i in range(n):
        val += a[i] - (mid + i+1)
    if val < 0:
        u = mid
    else:
        d = mid
ans1 = 0
ans2 = 0
#print(u,d)
for i in range(n):
    ans1 += abs(a[i] - (u + i+1))
    ans2 += abs(a[i] - (d + i+1))
print(min(ans1,ans2))
# Judge status: Accepted
N=int(input())
a=input().split()
T=int(a[0])
A=int(a[1])
H=[int(x) for x in input().split()]
t=abs(T-0.006*H[0]-A)
s=0
for i in range(N):
    if t>abs(T-0.006*H[i]-A):
        t=abs(T-0.006*H[i]-A)
        s=i
        

print(s+1)
# Judge status: Accepted
n,m=map(int,input().split())
stu=[]
poi=[]
for i in range(n):
    a,b=map(int,input().split())
    stu.append([a,b])
for i in range(m):
    a,b=map(int,input().split())
    poi.append([a,b])
for i in stu:
    ans=float("inf")
    ans_index=0
    ans_lis=[abs(i[0]-j[0])+abs(i[1]-j[1]) for j in poi]
    print(ans_lis.index(min(ans_lis))+1)
# Judge status: Accepted
l,r = map(int,input().split())
m = 2018
if r - l >= 2019:
    print(0)
    exit()
else:
    for i in range(l,r):
        for j in  range(i+1,r+1):
            m = min(m,i*j % 2019)
print(m)
# Judge status: Accepted
s = [list(input()) for _ in range(3)]

n_row = 0

dic = {0:"A",1:"B",2:"C"}
s_fix = {"a":0,"b":1,"c":2}

while len(s[n_row]):    
    n_row = s_fix[s[n_row].pop(0)] 

print(dic[n_row])
# Judge status: Accepted
x,y = map(int, input().split())
ans = 0

if (x==0 and y>0) or (y==0 and x<0):
  ans = abs(abs(y)-abs(x))
elif (x==0 and y<0) or (y==0 and x>0):
  ans = abs(abs(y)-abs(x))+1
else:
  ans = abs(abs(y)-abs(x))
  if x>0 and y>0:
    if x>y:
      ans += 2
  elif x>0 and y<0:
    ans += 1
  elif x<0 and y>0:
    ans += 1
  elif x<0 and y<0:
    if x>y:
      ans += 2

print(ans)
# Judge status: Wrong Answer
a, b, k = [int(x) for x in input().split()]

wk1 = list(range(a, min(a+k, b)))
wk2 = list(range(max(b-k+1, a), b+1))

for c in (wk1 + wk2):
    print(c)
# Judge status: Accepted
a,b,c,k = map(int,input().split())
ans = b - a

if k % 2 == 0:
    ans = a - b
    
print(ans)
# Judge status: Accepted
k=input()
s=raw_input()
if len(s)>k:
  print s[:k]+'...'
else:
  print s
# Judge status: Accepted
import math
N = int(input())
O = N // 2 + N % 2
print(O)
# Judge status: Accepted
n = int(input())
li_a = []
for i in range(n):
  a = list(map(int, input().split()))
  li_a.append(a)
li = list(sorted(li_a))
ans = 0
b = li[0][0] + li[0][1]
for i in range(n-1):
  if li[i+1][0] - li[i+1][1] >= b:
    b = li[i+1][0] + li[i+1][1]
  else:
    b = min(b, li[i+1][0]+li[i+1][1])
    ans += 1
print(n-ans)
# Judge status: Accepted
s = input()
if int(s[6]) <= 4 and int(s[5]) == 0:
  print("Heisei")
else:
  print("TBD")
# Judge status: Accepted
import itertools
N = int(input())
L = list(map(int, input().split()))

cnt = 0
for i in itertools.combinations(L, 3):
    # print(i)
    # print(i[0],i[1],i[2])

    if i[0] == i[1] or i[0] == i[2] or i[1] == i[2]:
        continue

    ij = i[0]+i[1] > i[2]
    ik = i[0]+i[2] > i[1]
    jk = i[1]+i[2] > i[0]

    if ij + ik + jk == 3:
        cnt += 1

print(cnt)
# Judge status: Wrong Answer
c, a, b= input().split()
print(a, b, c)
# Judge status: Accepted
N,C,K,*T=map(int, open(0).read().split())
T=sorted(T)
ans=0
cap=0
s=-1
for t in T:
    if t<=s and cap>0:
        cap-=1
    else:
        s=t+K
        cap=C-1
        ans+=1
print(ans)
# Judge status: Accepted
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

mp_score = {"r": P, "s": R, "p": S}

lines = [""] * K
for ix in range(len(T)):
    lines[ix%K] += T[ix]

ans = 0
for l in lines:
    before = ""
    for c in l:
        if before == c:
            before = ""

        else:
            ans += mp_score[c]
            before = c

print(ans)
# Judge status: Wrong Answer
import sys

N = int(input())
CSF = [list(map(int, sys.stdin.readline().rsplit())) for _ in range(N - 1)]

for i in range(N - 1):
    res = 0
    for c, s, f in CSF[i:]:
        if res < s:
            res = s + c
        elif res % f == 0:
            res += c
        else:
            res += res % f + c
    print(res)
print(0)
# Judge status: Wrong Answer
S = input()
T = input()
A = len(T)
for i in range(len(T)):
    M = S.find(T[i:])
    if M >= i and A > i:
        A = i
for i in range(1,len(T)):
    M = S.rfind(T[:i])
    if M >= i and A > i:
        A = i
print(A)
# Judge status: Accepted
_ = input()
nums = list(map(int, input().split()))
ans = 1

if 0 in nums:
  ans = 0
 
for num in nums:
    if ans <= 10 ** 18:
        ans *= num
    else:
        break
 
print(ans if ans <= 10**18 else -1)
# Judge status: Accepted
n = int(input())
l = [int(i) for i in input().split()]

orderd = [i for i in range(1,n+1)]
ans = 0
for i in range(n-1):
    if l[i]== orderd[i]:
        l[i],l[i+1] = l[i+1],l[i] 
        ans += 1

print(ans + 1 if l[-1] == n else ans)
# Judge status: Wrong Answer

def main():
    s = input()
    if s == "ABC" :
        print("ARC")
    else:
        print("ARC")

if __name__ == "__main__":
    main()
# Judge status: Accepted
print((((int(input())-1)//111)+1)*111)
# Judge status: Accepted
n, d = map(int, input().split())

area = (d*2)+1
if n%area == 0:
    ans = int(n//area)
else:
    ans = int(n//area) + 1

print(ans)
# Judge status: Wrong Answer
N,A,B=map(int, input().split())
if (A-B)%2==0:
    print(abs((A-B))//2)
else:
    a=max(A-1,B-1)
    b=max(N-A,N-B)
    print(min(a,b))
# Judge status: Accepted
N,X=map(int,input().split())
A=list(map(int,input().split()))
B=[]
for i in A:
  B.append(abs(X-i))

import functools
import fractions
gcd=functools.reduce(fractions.gcd,B)
print(gcd)
# Judge status: Wrong Answer
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = 0

for i in range(1,a+1):
  if i >= b:
    e += d
  else:
    e += c
print(e)
# Judge status: Wrong Answer
N = int(input())

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

K = 1

ans = []
ARC = []
ABC = []
for j in range(1, max(d)):
    for i in range(N):
        if (d[i] >= K):
            ARC.append(d[i])
        else:
            ABC.append(d[i])
    if (len(ARC) == len(ABC)):
        ans.append(K)
    else:
        ARC = []
        ABC = []
    K += 1

print(len(ans))
# Judge status: Accepted
s,w = map(int,input().rstrip().split(" "))
if w >= s:
    print("unsafe")
else:
    print("safe")
# Judge status: Accepted
a=int(input())
b=int(input())
print (list(set([1,2,3])-set([a,b]))[0])
# Judge status: Wrong Answer
from sys import stdin
#T = int(stdin.readline())
S = stdin.readline().strip()
print(S)
if S == "AAA" or S == "BBB":
    print('No')
else:
    print('Yes')
# Judge status: Accepted
def check(lis,k,mid):
	for i in lis:
		if(i%mid==0):
			k+=1
		k-=(i//mid)
	return k>=0
n,k=map(int,input().split())
lis=list(map(int,input().split()))
a,b=1,max(lis)
ans=b
while(a<=b):
	mid=(a+b)//2
	if(check(lis,k,mid)):
		ans=mid
		b=mid-1
	else:
		a=mid+1
print(ans)
# Judge status: Accepted
n = int(input())
p = list(map(int, input().split()))
ans = 0
min = p[0]

for i in range(len(p)):
    if p[i]<=min:
        min = p[i]
        ans += 1

print(ans)
# Judge status: Accepted
N, K = map(int, input().split())
alist = list(map(int, input().split()))

ans = 1
N -= K

while N > 0:
    N -= K-1
    ans += 1

print(ans)
# Judge status: Accepted
import numpy as np 

N,M = map(int,input().split())
AB = []
for i in range(N):
    a,b = map(int,input().split())
    AB.append([a,b])

need = M
cost = 0

AB.sort()

for i in range(N):
    if need - AB[i][1] >= 0:
        need -= AB[i][1]
        cost += AB[i][0]*AB[i][1]
    else:
        cost += AB[i][0]*need 
        break    

print(cost)
# Judge status: Wrong Answer
x, y = map(int, input().split())
count = abs(abs(x)-abs(y))

if x * y <= 0:
    count += 1
elif x * y > 0:
    if x < 0 and abs(x) < abs(y):
        count += 2
    elif x > 0 and abs(x) > abs(y):
        count += 2

print(count)
# Judge status: Accepted
from math import *
n,h=map(int,input().split())
a=[]
b=[]
for i in range(n):
    A,B=map(int,input().split())
    a.append(A)
    b.append(B)
aa=max(a)
b.sort(reverse=True)
ans=0
for i in range(n):
    if b[i]>aa:
        h-=b[i]
        ans+=1
        if h<=0:
            print(ans)
            exit()
print(ans+ceil(h/aa))
# Judge status: Accepted
a, b, c, d, e = map(int, input().split())
start = a*60 + b
end = c*60 + d

print(end - e - start)
# Judge status: Accepted
A,B=map(int,input().split())
import math
print(A*B//math.gcd(A,B))
# Judge status: Accepted
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
xyc = [tuple(map(int, input().split())) for _ in range(M)]

minP = min(a) + min(b)
for x, y, c in xyc:
    minP = min(a[x-1]+b[y-1]-c, minP)
print(minP)
# Judge status: Accepted
N = int(input())
dict = {}
dict['AC'] = 0
dict['WA'] = 0
dict['TLE'] = 0
dict['RE'] = 0

for i in range(N):
  s = input()
  dict[s] += 1
  
print('AC x',dict['AC'])
print('WA x',dict['WA'])
print('TLE x',dict['TLE'])
print('RE x',dict['RE'])
# Judge status: Accepted
n = input(); a = 0
for i in range(len(n)): a += int(n[i])
print(10) if a == 1 else print(a)
# Judge status: Wrong Answer
n = input()
p = input().split()
cnt = 1

for i in range(1, len(p)):
	if p[i-1] > p[i]:
		cnt += 1
	if p[i] == 1:
		break

print(cnt)
# Judge status: Accepted
N = int(input())
if N < 10:
    print(N)
else:
    str_N = str(N)
    ### 最上位以外すべて9 の場合はその値が最大値
    for n in str_N[1:]:
        if n != '9':
            ### それ以外は最上位の桁を一つ下げてあと全部9 が一番最大
            print(int(str_N[0]) - 1 + (len(str_N) - 1) * 9)
            break
    else:
        print(int(str_N[0]) + (len(str_N) - 1) * 9)
# Judge status: Accepted
x=int(input())
r=10**9 
l=0
while r-l>1:
    mid=(r+l)//2 
    if x<=mid*(mid+1)//2:
        r=mid
    else:
        l=mid

print(r)
# Judge status: Accepted

S = input()
print("x"*len(S))
# Judge status: Accepted
import sys
import itertools
# import numpy as np
import time
import math
import heapq
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
INF = 10 ** 9 + 7

# map(int, input().split())
# list(map(int, input().split()))

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

negs = 0
abs_min = INF
total = 0
for a in A:
    if a < 0:
        negs += 1
    abs_min = min(abs_min, abs(a))
    total += abs(a)

if negs % 2 == 0:
    print(total)
else:
    print(total - abs_min * 2)
# Judge status: Wrong Answer
n = int(input())

if n == 1: print(1)
else: print(2/n)
# Judge status: Accepted
N = input()

a = 0  # not borrowed
b = 0  # borrowed

t = int(N[-1])
a, b = a + t, a + (10 - t)

for i in range(len(N) - 2, -1, -1):
    t = int(N[i])
    a, b = min(a + t, b + (t + 1)), min(a + (10 - t), b + (10 - (t + 1)))
print(min(a, b + 1))
# Judge status: Accepted
a,b,c = [int(i) for i in input().split()]

if c == a + b or b == a + c or a == b + c:
	print("Yes")
else:
	print("No")
# Judge status: Accepted
#!python3

LI = lambda: list(map(int, input().split()))

# input
x, y = LI()


def group(num):
    if num == 2:
        return 0
    if num in {4, 6, 9, 11}:
        return 1
    return 2


def main():
    if group(x) == group(y):
        ans = "Yes"
    else:
        ans = "No"
    print(ans)


if __name__ == "__main__":
    main()
# Judge status: Accepted
n=int(input())
a=list(map(int, input().split()))
ans=10**9

for i in range(n):
    num=a[i]
    cnt=0
    while num%2==0:
        num/=2
        cnt+=1
    ans=min(ans, cnt)

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

S = [input() for i in range(0,N)]

C0=0 #AC
C1=0 #WA
C2=0 #TLE
C3=0 #RE

for i in range(0,N):
    if S[i]=='AC':
        C0+=1
    elif S[i]=='WA':
        C1+=1
    elif S[i]=='TLE':
        C2+=1
    elif S[i]=='RE':
        C3+=0

print('AC x', C0)
print('WA x', C1)
print('TLE x', C2)
print('RE x', C3)
# Judge status: Accepted
def solve():
    N = int(input())
    A = list(map(int, input().split()))
    ans = True
    m = 0
    for i in range(N-1):
        m = max(m, A[i])
        if m-1 > A[i+1]:
            ans = False
    return 'Yes' if ans else 'No'

print(solve())
# Judge status: Accepted
x,y=map(int,input().split())
if 2*x<=y and y<=4*x and y%2==0:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
N = input()

if '9' in N:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
H,W=(int(x) for x in input().split())
if H == 1 or W == 1:
  print(1)
  exit()
if (H * W) % 2 == 0:
  print((H * W) // 2)
else:
  print(((H * W) // 2) + 1)
# Judge status: Accepted
n, m = map(int, input().split())
print(abs(n - 2) * abs(m - 2))
# Judge status: Wrong Answer
import math

s = int(input())

x1 = 1000000000
y1 = 1
x2 = math.ceil(s / x1)
y2 = x2 * x1 - s

print(0, 0, x1, y1, x2, y2)
# Judge status: Accepted
A,B,C = map(int, input().split())
K = int(input())

while A>=B:
    B *= 2
    K -= 1
while B>=C:
    C *= 2
    K -= 1

if K < 0:
    print("No")
else:
    print("Yes")
# Judge status: Accepted
import sys

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline
    a,b=list(map(int, readline().strip().split()))
    if a==b:
        print("Draw")
        return
    if a==1:
        print("Alice")
        return
    if b==1:
        print("Bob")
        return
    if a>b:
        print("Alice")
        return
    else:
        print("Bob")
    return


resolve()
# Judge status: Accepted
n,k=map(int,input().split())
S=input()
now="0"
cnt=0
for s in S:
    if s!=now:
        cnt+=1
    now=s

print(min(n-cnt+2*k,n-1))
# Judge status: Accepted
import sys

def S(): return sys.stdin.readline().rstrip()

N,L = map(int,S().split())

A = [L+i for i in range(N)]

if A[0] >= 0:
    print(sum(A)-A[0])
elif A[-1] <= 0:
    print(sum(A)-A[-1])
else:
    print(sum(A))
# Judge status: Accepted
N = int(input())
a = list(map(int,(input().split())))
from collections import Counter
c = Counter(a)
L = []
LL = []
for k in c.keys():
    if c[k] >= 2:
        L.append(k)
    if c[k] >= 4:
        LL.append(k)
M = 0 
if LL:
    M = max(LL)**2
if len(L) < 2:
    print(0)
else:
    L.sort(reverse=True)
    print(max(L[0]*L[1],M))
# Judge status: Accepted
a, b, x = map(int, input().split())
if a <= x <= a + b:
  print('YES')
else:
  print('NO')
# Judge status: Accepted
X = list()
Y = list()
D = list()
score = 0

n,d = map(int, input().split())
for i in range(n):
    x, y = map(int, input().split())
    X.append(x)
    Y.append(y)

for i in range(n):
    dis = (X[i]**2 + Y[i]**2)**0.5
    D.append(dis)

for i in range(n):
    if d >= D[i]:
        score += 1

print(score)
# Judge status: Wrong Answer
a, b = map(int, input().split())
mod = pow(10,9) + 7

def cal(a,i):
  min = i*(i+1)/2
  max = a*(a+1)/2 - (a-i)*(a-i+1)/2
  return max - min + 1

count = 0
for i in range(a-b+1):
  count += cal(a,i+b)
print(count % mod)
# Judge status: Accepted
N=int(input())
a=[]
for b in range(1,N+1,1):
  count=0
  while b%2 == 0:
    count+=1
    b/=2
  a.append(count)

print(a.index(max(a))+1)
# Judge status: Wrong Answer
n=int(input())
i=2
counter_set=set()
tmp=1
flag=True
while n!=1 :
    if n%i==0:
        flag=False
        n=n//i
        tmp=tmp*i
        if tmp not in counter_set:
            counter_set.add(tmp)
            tmp=1
    else:
        i+=1
        flag=True
    if i>=(n)**(1/2) and flag:
        counter_set.add(n)
        break
print(len(counter_set))
# Judge status: Wrong Answer
S, W = map(int, input().split())
def f():
  if W > S:
    return "unsafe"
  else:
    return "safe"
print(f())
# Judge status: Accepted
def resolve():
	x, a, b = map(int, input().split())
	if b - a > x:
		print('dangerous')
	elif a >= b:
		print('delicious')
	else:
		print('safe')
resolve()
# Judge status: Accepted
# https://atcoder.jp/contests/abc055/tasks/abc055_a

N = int(input())

x = 800 * N
y = (N // 15) * 200

print(x - y)
# Judge status: Accepted
n, m = map(int, input().split())
sd = []
cp = []

for i in range(n):
  sd.append([int(j) for j in input().split()])
for i in range(m):
  cp.append([int(j) for j in input().split()])  
  
dist = [[0 for i in range(m)] for j in range(n)]

for i in range(n):
  for j in range(m):
    dist[i][j] = abs(sd[i][0] - cp[j][0]) + abs(sd[i][1] - cp[j][1])
    
for i in range(n):
  print(dist[i].index(min(dist[i]))+1)
# Judge status: Accepted
N = int(input())
H = list(map(int, input().split()))

res = []
cnt = 0
for i in range(N-1):
    if H[i+1] <= H[i]:
        cnt += 1
        if i == N - 2:
            res.append(cnt)
    else:
        res.append(cnt)
        cnt = 0
if res == []:
    print(0)
else:
    print(max(res))
# Judge status: Wrong Answer
n, p, *a = map(int, open(0).read().split())
if n == 1:
    if a[0] % 2 == 1 and p == 1:
        print(1)
    elif a[0] % 2 == 0 and p == 0:
        print(2)
    else:
        print(0)
else:
    print(2**(n -1))
# Judge status: Wrong Answer
N = int(input())
ans = [int(input()) for i in range(N)]
ans.sort()
total = 0
tmp = 1
for i in range(N-1):
  if ans[i]  == ans[i+1]:
    tmp += 1
  else:
    if tmp %2 == 1:
      total += 1
    tmp = 1
print(total)
# Judge status: Wrong Answer
a = int(input())
b = a + a^2 + a^3
print(int(b))
# Judge status: Accepted
from collections import defaultdict
n = int(input())
a = list(map(int,input().split()))
d = defaultdict(int)
for x in a:
  d[x] += 1
  
s = 0
for k,v in d.items():
  s += v * (v-1) // 2
for x in a:
  c = d[x] - 1
  print(s - c)
# Judge status: Accepted
S, T = input().split()
A, B = map(int,input().split())
U = input()

if S == U :
  a = A - 1
  b = B
else :
  a = A
  b = B - 1

print(a, b)
# Judge status: Accepted
#入力 A:使う1個当たりのタップの口数 B:最終的にここまで増やす差し込み口の数
A, B = list(map(int,input().split()))
#タップの必要数をans, 差し込み口の数をsocとする
ans = 0
soc = 1
#差し込み口はタップを使うと増えるが一つ使うと必ず1つ差し込み口を消費する。
while soc < B:
  soc -= 1
  ans += 1
  soc += A
#結果  
print(ans)
# Judge status: Accepted
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

def main():
    A, B, C = map(int, input().split())

    print('Yes') if A <= C <= B else print('No')

if __name__ == '__main__':
    main()
# Judge status: Accepted
X, Y, A, B, C = map(int ,input().split(' '))
p = list(map(int ,input().split(' ')))
q = list(map(int ,input().split(' ')))
R = list(map(int ,input().split(' ')))
 
eat = sorted(p, reverse=True)[:X]
eat[len(eat):] = sorted(q, reverse=True)[:Y]
eat[len(eat):] = R
eat.sort(reverse=True)


print(sum(eat[:X+Y]))
# Judge status: Accepted
c = [0]*100002
input()
for x in map(int, input().split()):
  c[x] += 1
  c[x+1] += 1
  c[x+2] += 1
print(max(c))
# Judge status: Wrong Answer
a, b, c = map(int, input().split())

if b - a == c - b :
	print("Yes")
else:
	print("No")
# Judge status: Wrong Answer
# -*- coding: utf-8 -*-
import sys

N,M = map( int, input().split() )
list_str_P_S = [input().split() for i in range(M)]
#-----

count_AC=0
count_WA=0
check_question_no=[]

for L in list_str_P_S:
  str_number = L[0]
  result = L[1]
  
  if ( str_number in check_question_no ):
    continue
  else:
    if result == "WA":
      count_WA += 1
    elif result == "AC":
      count_AC += 1
      check_question_no.append(str_number)
      
print(count_AC,count_WA)
# Judge status: Accepted
c = input()
print("vowel" if c in "aioueo" else "consonant")
# Judge status: Accepted
import collections
n = int(input())
line = list(map(int,input().split()))
box = []
for i in line:
  box.append(i)
  box.append(i-1)
  box.append(i+1)
newbox = collections.Counter(box)
answer = max(newbox.values())
print(answer)
# Judge status: Wrong Answer
# -*- coding: utf-8 -*-
 
## Library
 
import sys
from fractions import gcd
import math
from math import ceil,floor
import collections
from collections import Counter
import itertools

## input
 
# N=int(input())
# A,B,C,D=map(int, input().split())
# S = input()
# yoko = list(map(int, input().split()))
# tate = [int(input()) for _ in range(N)]
# N, M = map(int,input().split()) 
#    P = [list(map(int,input().split())) for i in range(M)]
 
X=int(input())

# X x ans = 360
# ans = 360/X

if X*360//math.gcd(X,360) == 360:
    print(360//X)
else:
    print(X*360)
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline

a,b,c,d = map(int,input().split())
if a >= 0 and c >= 0:
    print(b*d)
elif a >= 0 and c < 0 and d >= 0:
    print(b*d)
elif a >= 0 and c < 0 and d < 0:
    print(a*d)
elif a < 0 and c < 0:
    print(a*c)
elif a < 0 and b >= 0 and c >=0:
    print(b*d)
elif a < 0 and b < 0 and c >= 0:
    print(b * c)
# Judge status: Accepted
N, x = map(int, input().split())
a = [int(i) for i in input().split()]
ans = 0

if a[0] > x:
    ans += a[0] - x
    a[0] = x

for i in range(1, N):
    if a[i] + a[i - 1] > x:
        ans += a[i] - (x - a[i - 1])
        a[i] = x - a[i - 1]

print(ans)
# Judge status: Accepted
print("0") if input()=="1" else print("1")
# Judge status: Accepted
s = input()
ans = '2018' + s[4:]
print(ans)
# Judge status: Accepted
S = input()
T = input()
if S == T[:-1]:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n, k = map(int, input().split())
L=list(input())
cnt=0
if L[0]=='R' and L[1]=='R':
	cnt+=1 

for i in range(1,n-1):
	if L[i]=='R' and L[i+1]=='R':
		cnt+=1
	if L[i]=='L' and L[i-1]=='L':
		cnt+=1

if L[n-1]=='L' and L[n-2]=='L':
	cnt+=1

print(min(cnt+2*k,n-1))
# 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")


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
from queue import deque
q = deque([a[0]])
ans = 0
for num in a[1:]:
    ans += q.popleft()
    q.append(num)
    q.append(num)
print(ans)