peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
s = input()
n = len(s)
a, b = (n-1)//2, ((n+3)//2)+1
if s[0:a] == ''.join(reversed(s[0:a])) and s[b:] == ''.join(reversed(s[b:])):
	print("Yes")
else:
	print("No")
# Judge status: Wrong Answer
n = int(input())
li = [list(map(int,input().split())) for i in range(n)]
dp = [[0 for i in range(3)] for j in range(n)]
dp[0] = [max(li[0])]*3
#print(dp)

for i in range(n-1):
    for j in range(3):
        for k in range(3):
            if j == k: #同じことを2日連続はできない
                continue
            dp[i+1][k] = max(dp[i+1][k], li[i+1][j] + dp[i][k])
#print(dp)
print(max(dp[n-1]))
# Judge status: Wrong Answer
a = int(input())
b = int(input())

if a!=1 or b!=1:
  print(1)
elif a!=2 or b!=2:
  print(2)
else:
  print(3)
# Judge status: Wrong Answer
import itertools

N = int(input())
S = input()

r = len(list(filter(lambda x: x == "R", S)))
g = len(list(filter(lambda x: x == "G", S)))
b = len(list(filter(lambda x: x == "B", S)))

# print("r:{}, g:{}, b:{}".format(r, g, b))

ans = r * g * b
RGB = itertools.permutations(["R", "G", "B"], 3)
for i in range(1, N):
    for j in range(1, N-i*2):
        if (S[j], S[j+i], S[j+2*i]) in RGB:
            ans -= 1

print(ans)
# Judge status: Accepted
s=int(input())
def calc(n):
  if n % 2 == 0:
    return n / 2
  else:
    return 3*n +1
ans = []
ans.append(s)
for i in range(1000001):
  if calc(ans[i]) in ans:
    print(len(ans) +1)
    exit()
  else:
    ans.append(int(calc(ans[i])))
# Judge status: Accepted
A,B=map(int,input().split(' '))
if A<=8 and B <= 8:
    print('Yay!')
else:
    print(':(')
# Judge status: Accepted
def main():
    T = input()

    print(T.replace('?', 'D'))


if __name__ == "__main__":
    main()
# Judge status: Accepted
S = input()

if S == 'SUN':
  print(7)
elif S == 'MON':
  print(6)
elif S == 'TUE':
  print(5)
elif S == 'WED':
  print(4)
elif S == 'THU':
  print(3)
elif S == 'FRI':
  print(2)
elif S == 'SAT':
  print(1)
# Judge status: Wrong Answer
def iroha():
    string = input()
    Capital = string[0]
    print("A" + Capital + "C")

if __name__ == "__main__":
    iroha()
# Judge status: Accepted
N = int(input())
nums = list(map(int, input().split()))
al = 0
part = {}
for i in range(N):
    if nums[i] in part:
        al += part[nums[i]]
        part[nums[i]] += 1
    else:
        part[nums[i]] = 1

for i in range(N):
    print(al - part[nums[i]] + 1)
# Judge status: Wrong Answer
w,a,b = map(int,input().split())
print(b-(a+w))
# Judge status: Wrong Answer
s = [input()]
q = int(input())
for _ in range(q):
    i = input().split()
    if int(i[0]) == 1:
        s = s[::-1]
    elif int(i[0]) == 2:
        if int(i[1]) == 1:
            s.insert(0, i[2])
        elif int(i[1]) == 2:
            s.append(i[2])

print(''.join(s))
# Judge status: Accepted
K,a,b = map(int,input().split())
count = 1
if (b-a) <= 2:
    count += K
else:
    K -= (a-1)
    count += (a-1)
    if K >= 2:
        count += K//2 * (b-a)
        if K % 2 ==1:
            count += 1
    else:
        count += 1
print(count)
# Judge status: Accepted
from collections import Counter
N, K = map(int, input().split())
xd=[]
for i in range(K):
    d = int(input())
    x = list(map(int, input().split()))
    xd.extend(x)

xd= Counter(xd)

print(N-len(xd))
# Judge status: Accepted
N=int(input())
r=[0]*N
from itertools import product
for x,y,z in product(range(1,100),repeat=3):
    p=x*x+y*y+z*z+x*y+y*z+z*x
    if 0<p<=N:
        r[p-1]+=1
print(*r,sep='\n')
# Judge status: Accepted
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n,m,x,y = LI()
X = LI()
Y = LI()
mx = max(X)
my = min(Y)
for i in range(x+1,y+1):
    if mx < i <= my:
        print('No War')
        quit()
print('War')
# Judge status: Wrong Answer
n,m=map(int,input().split())
if n==1 or m==1 and n!=m:
  print(n*m-2)
elif n==1 and m==1:
  print(0)
else:
  print((n-2)*(m-2))
# Judge status: Wrong Answer
import itertools
import numpy as np
n, m, x = map(int, input().split())
l = [list(map(int, input().split())) for _ in range(n)]
l = sorted(l)
l = np.array(l)
ans = np.sum(l, 0)[0]
ans_s = np.sum(l, 0)
if np.any(ans_s[1:] < x):
    print(-1)
    exit()
count = 0
for i in range(1, m + 1):
    for j in itertools.combinations(l, i):
        tot = np.sum(j, 0)
        if np.all(tot[1:] >= x) and tot[0] < ans:
            ans = tot[0]
print(int(ans))
# Judge status: Accepted
import sys
def input(): return sys.stdin.readline().strip()


def main():
    a, b = map(int, input().split())
    if a <= 8 and b <= 8: print("Yay!")
    else: print(":(")

if __name__ == "__main__":
    main()
# Judge status: Accepted

def comb(n, r, mod=10 ** 9 + 7):
    n1 = n + 1
    r = min(n, n - r)
    numer = denom = 1
    for i in range(1, r + 1):
        numer = numer * (n1 - i) % mod
        denom = denom * i % mod
    return numer * pow(denom, mod - 2, mod) % mod

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

if (x+y) % 3 != 0:
    print(0)
    exit()

n = (2*y-x) // 3
m = (2*x-y) // 3

if n*m < 0:
    print(0)
    exit()

print(comb(n+m, m))
# Judge status: Wrong Answer
#AtCorder Begginer Contest 103 - String Rotation
S=input()
T=input()
flg=0
for i in range(len(T)):
    T=T[-1]+T[:-1]
    if S == T:
        print("YES")
        break
else:
    print("NO")
# Judge status: Wrong Answer
N, M = map(int, input().split())
digits = [-1 for _ in range(N+1)]
for __ in range(M):
  digit, num = map(int, input().split())
  if digit == 1 and num == 0:
    print(-1)
    exit()
  elif digits[digit] != -1 and num != digits[digit]:
    print(-1)
  else:
    digits[digit] = num
answer = 0
for i in range(1, N+1):
  if digits[i] == -1:
    if i == 1:
      answer += 1*10*(N-i)
  else:
    answer += digits[i]*10**(N-i)
print(answer)
# Judge status: Accepted
N,K = map(int,input().split())
a = N % K
if K - a < a:
    print(K-a)
else:
    print(a)
# Judge status: Wrong Answer
a,b,c=map(int,input().split())
print((max(a,b,c)*3-(a+b+c))//2)
# Judge status: Wrong Answer
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N, *A = map(int, read().split())

INF = 1 << 30

bound = [0] * (N + 1)
bound[0] = 1
ok = True
for n in range(1, N + 1):
    bound[n] = min(INF, (bound[n - 1] - A[n - 1]) * 2)
    if bound[n] < A[n]:
        ok = False

if not ok:
    print(-1)
    exit()

B = [0] * (N + 2)
for n in range(N, -1, -1):
    x = min(bound[n], B[n + 1] + A[n])
    B[n] = x

print(sum(B))
# Judge status: Wrong Answer
N = int(input())
X = list(map(int, input().split()))

for i in range(N):
  if i>N/2:
    print(X[N//2])
  else:
    print(X[N//2-1])
# Judge status: Accepted
n,k = list(map(int,input().split()))
count = 1

while True:
    if n < k ** count:
        break
    else:
        count += 1

print(count)
# Judge status: Accepted
s = input().split()[1]
print('A'+s[0]+'C')
# Judge status: Accepted
import collections as c
input();a=c.Counter(i//400 for i in [*map(int,input().split())])
b,c=len(set([i for i in a.keys()if i<8])),sum([j for i,j in a.items()if i>=8])
print([b,1][b==0],b+c)
# Judge status: Accepted
a, b, c = map(int, input().split())
print('Yes' if c <=a+b else 'No')
# Judge status: Accepted
a,b=map(int,input().split())
print(a-(b<a))
# Judge status: Wrong Answer
n = int(input())
L = list(map(int, input().split()))
cnt = 1
L2 = [''] * (n - 1)
for i in range(n - 1):
    L2[i] = L[i + 1] - L[i]
j = 0
flag = 1
for j in range(n - 1):
    if flag == 1:
        prev = L2[j]
        flag = 0
    else:
        if L2[j] * prev < 0:
            prev = L2[j]
            cnt += 1
            flag = 1
print(cnt)
# Judge status: Accepted
#ABC090-B
a,b = map(int,input().split())

def kaibun(n):
    flg = True
    for i in range(len(str(n))//2):
        if str(n)[i] != str(n)[-1-i]:
            flg = False
            break
            
    if flg:
        return True
    else:
        return False
    
cnt = 0
for i in range(a,b+1):
    if kaibun(i):
        cnt += 1
        
print(cnt)
# Judge status: Wrong Answer
a = int(input())
b = a % 28

c = b % 7
d = c % 4
if c % 4 ==0:
  print('Yes')
  exit()
elif d % 7 ==0:
  print('Yes')
  exit()
print('No')
# Judge status: Accepted
n = int(input())
a = [input() for _ in range(n)]

a.sort()
cnt = 1
for i in range(1, n):
  if a[i-1] != a[i]:
    cnt += 1
print(cnt)
# Judge status: Accepted
S=input()
stack=[]
count=0
for s in S:
    if not stack:
        stack.append(s)
    elif stack[-1]!=s:
        stack.pop()
        count+=2
    else:
        stack.append(s)
print(count)
# Judge status: Accepted
N,M = list(map(int,input().split()))
ac = [0]*N
wa = [0]*N
for i in range(M):
    p,s = list(map(str,input().split()))
    p = int(p)
    if s == 'AC':
        ac[p - 1] = 1
    elif s == 'WA':
        if ac[p - 1] == 0:
            wa[p - 1] += 1
for i in range(N):
    if ac[i] == 0:
        wa[i] = 0
print(sum(ac),sum(wa))
# Judge status: Accepted
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if v <= w:
    if a != b:
        print('NO')
    else:
        print('YES')
else:
    if abs(a - b) <= abs(v - w) * t:
        print('YES')
    else:
        print('NO')
# Judge status: Accepted
# input
A1, A2, A3 = map(int, input().split())

if sum([A1, A2, A3]) >= 22:
    print("bust")
else:
    print("win")
# Judge status: Wrong Answer
import sys

a = []
for l in sys.stdin:
    a.append(l)
    
N,D = a[0].split(' ')
N = int(N)
D = int(D)
D = D*D

x = []
y = []
count = 0
dist = 0.0
for i in range(1,N):
	x, y = a[i].split(' ')
	x = int(x)
	y = int(y)
	dist = x*x+y*y
	if dist <= D:
		count = count + 1

print(count)
# Judge status: Accepted
import re

def solve(s, t):
    s = s.replace('?', '.')
    ls, lt = len(s), len(t)

    if(ls < lt):
        return 'UNRESTORABLE'

    ans = []
    for i in range(ls - lt + 1):
        result = re.match(s[i:i + lt], t)
        if result is None:
            continue
        ans.append((s[:i] + t + s[i + lt:]).replace('.', 'a'))

    if not ans:
        return 'UNRESTORABLE'
    return min(ans)

s = input()
t = input()

print(solve(s, t))
# Judge status: Wrong Answer
def check(A,B,C):
  if A < C and C < B:
    return Yes
  return No
# Judge status: Accepted
a,b = map(int,input().split())
print( a-1 if a>b else a)
# Judge status: Accepted
N = int(input())

x = N * 800
# //は切り捨ての除算
# 例えば、5//2の時は求まる2となる。5/2の時の商のみ。
y = N // 15 * 200
print(x - y)
# Judge status: Wrong Answer
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
ans = sum(x >= (sum(A) // (4 * M)) for x in A)
print('Yes' if ans >= M > 0 else 'No')
# Judge status: Accepted
n = int(input())

prev_t, prev_x, prev_y = 0, 0, 0
for _ in range(n):
    t, x, y = map(int, input().split())
    if (abs(x - prev_x) + abs(y - prev_y) <= t - prev_t and
        (abs(x - prev_x) + abs(y - prev_y)) % 2 == (t - prev_t) % 2):
        prev_t, prev_x, prev_y = t, x, y
        continue
    else:
        print('No')
        break
else:
    print('Yes')
# Judge status: Accepted
N = int(input())
A_list = list(map(int, input().split()))
M = 10**6+1
cnt = [0 for _ in range(M)]

for i in A_list:
    if cnt[i] != 0:
        cnt[i] = 2
        continue
    for j in range(i, M, i): cnt[j] += 1

ans = 0
for k in A_list:
    if cnt[k] == 1: ans += 1
print(ans)
# Judge status: Accepted
X = input()

def solve(X):
    if X == '0':
        return 0
    if len(X) % 2 == 0:
        ans = 0
        y = len(X)
        while (y > 1):
            if y % 2 == 0:
                ans += 9 * 10**(y-2)
            y -= 2
        return ans 
    else:
        ans = int(X) - 10**(len(X)-1) + 1
        return ans + solve(str(10**(len(X)-1)-1))

print(solve(X))
# Judge status: Wrong Answer
A,B,C=sorted(input().split())

print(int(A+B)+int(C))
# Judge status: Wrong Answer
x = int(input())

if x >= 1800:
    print(1)
elif x >= 1600:
    print(2)
elif x >= 1600:
    print(2)
elif x >= 1400:
    print(3)
elif x >= 1200:
    print(4)
elif x >= 1000:
    print(5)
elif x >= 800:
    print(6)
elif x >= 600:
    print(7)
elif x >= 800:
    print(8)
# Judge status: Accepted
n, a, b, c, d = map(int, input().split())
s = ['S'] + list(input())

for i in range(a, max(c, d)):
    if s[i] == '#' and s[i-1] == '#':
        print('No')
        exit()

if c < d:
    print('Yes')
else:
    for i in range(b, d+1):
        if s[i-1] == '.' and s[i] == '.' and s[i+1] == '.':
            print('Yes')
            exit()
    print('No')
# Judge status: Accepted
N, M = map(int, input().split())

if M % 2 == 0:
    m = (2 * M + 1) // 2 + 1
else:
    m = (2 * M + 1) // 2

i = 1
while i <= m // 2:
    print(i, m - i + 1)
    i += 1

j = 1
while j <= (2 * M + 1 - m) // 2:
    print(m + j, (2 * M + 1) - j + 1)
    j += 1
# Judge status: Accepted
import sys

k, x = map(int, sys.stdin.readline().split())

def main():
    l = max(-10 ** 6, x - (k - 1))
    r = min(10 ** 6, x + (k - 1))
    return range(l, r + 1)

if __name__ == '__main__':
    ans = main()
    print(*ans, sep =' ')
# Judge status: Wrong Answer
N = int(input())

A = [int(_) for _ in input().split()]


flag=0
count=1
for j in range(0,N-1):
    if A[j]>A[j+1] and flag==1:
        count+=1
        flag=0

    elif A[j]>A[j+1] and flag==0:
        flag=-1

    elif A[j]<A[j+1] and flag==-1:
        count+=1
        flag=0
    elif A[j]<A[j+1] and flag==0:
        flag=1

    if A[j]==A[j+1]:
        flag=0


print(count)
# Judge status: Accepted
a, b = map(int, input().split())
if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Bob")
# Judge status: Wrong Answer
a, b, c, d = map(int, input().split())

if (abs(a - b) <= d and abs(b - c) <= d) or abs(a - c) < d:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N = int(input())
ans = -1*float('inf')
while N >= 1:
  if (N**0.5)%2 == 1 or (N**0.5)%2 == 0:
    ans = max(ans, N)
    break
  N -= 1
print(ans)
# Judge status: Accepted
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

N = int(input())
A = [None] + list(map(int, input().split()))
answer = []
B = [0] * (N + 1)

for n in range(1, N + 1)[::-1]:
    x = sum(B[2*n::n])
    if x % 2 == A[n]:
        continue
    B[n] += 1
    answer.append(str(n))

print(len(answer))
print(' '.join(answer))
# Judge status: Accepted
from math import factorial
n, m = map(int, input().split())
c_n = factorial(n) / (factorial(2) * factorial(n - 2)) if n > 1 else 0
c_m = factorial(m) / (factorial(2) * factorial(m - 2)) if m > 1 else 0
ans = int(c_n) + int(c_m)
print(ans)
# Judge status: Wrong Answer
from math import floor
N = int(input())
if N%2 == 0:
    ans = (1+N-1)*((N-1)//2) + floor((N-1)/2)
else:
    ans = (1+N-1)*((N-1)//2)
print(ans)
# Judge status: Accepted
N=int(input())
A=list(map(int, input().split()))
Q=int(input())
B=[list(map(int, input().split())) for _ in range(Q)]
D={}
ma=0
for i in A:
  ma+=i
  if i not in D:
    D[i]=1
  else:
    D[i]+=1
    
for b,c in B:
  if b in D:
    f=D[b]
    if c in D:
      t=D[c]
    else:
      t=0
    
    D[c]=f+t
    D[b]=0
    ma+=(c-b)*f
  print(ma)
# Judge status: Wrong Answer
n = int(input())
k = int(input())
x = int(input())
y = int(input())

print(n*x + max(k-n, 0)*y)
# Judge status: Accepted
s=int(input())
if s%9==0:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
S = input()

st = ['MON','TUE','WED','THU','FRI','SAT','SUN']

for i in range(7):
  if S==st[i]:
    print(i+1)
# Judge status: Wrong Answer
n = input()
x = 0
for i in range(int(n)):
    a,b = input().split(" ")
    if a == b:
        x+=1
    else: x = 0
    if x==3:
        print("Yes")
        break
if x==0:
    print("No")
# Judge status: Wrong Answer
a = int(input())
b = int(input())
h = int(input())

print((a+b)*h/2)
# Judge status: Accepted
n = (input())
#a, b = map(int,input().split())
#l = list(map(int,input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
print('Yes') if '9' in n else print('No')
# Judge status: Wrong Answer
N = int(input())
S = []
P = []
for i in range(N):
    s,p = input().split()
    S.append(s)
    P.append(int(p))
Sset = sorted(list(set(S)))

dict1 = {}
for i in range(N):
    dict1[P[i]] = S[i]

print(Sset)

for k in Sset:
    U = [i for i, j in dict1.items() if j == k]
    V = sorted(U,reverse=True)
    for l in V:
        print(P.index(l) + 1)
# Judge status: Wrong Answer
x,y=map(int,input().split())

if x==y:
  print(-1)
elif y==1:
  print(-1)
else:
  for i in range(1,10**10):
    if x*i<=10**18:
      break
    elif x*i%y !=0:
      print(x*i)
      break
# Judge status: Wrong Answer
def main():
    sx, sy, tx, ty = map(int, input().split())
    ans = solve(sx, sy, tx, ty)
    print(ans)


def solve(sx, sy, tx, ty):
    dx = tx - sx
    dy = ty - sy
    st = 'U' * dy + 'R' * dx
    ts = 'D' * dy + 'L' * dy
    rt1 = st + ts
    rt2 = 'L' + 'U' + st + 'R' + 'D' + 'R' + 'D' + ts + 'L' + 'U'
    ans = rt1 + rt2
    return ans


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

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

Sum = 0


for i in range(n):
	for j in range(i,n):
		Sum = Sum + i*j

print(Sum)
# Judge status: Accepted
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
from itertools import combinations
import bisect
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a,b,c=mi()
l=[0]*a
for i in range(c):
  j=ii()
  l[j-1]+=1
for k in l:
  if b+k-c>0:
    print("Yes")
  else:
    print("No")
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))

flag = [False]*8
t = 0
for i in a:
  if i < 400: flag[0] = True
  elif i < 800: flag[1] = True
  elif i < 1200: flag[2] = True
  elif i < 1600: flag[3] = True
  elif i < 2000: flag[4] = True
  elif i < 2400: flag[5] = True
  elif i < 2800: flag[6] = True
  elif i < 3200: flag[7] = True
  elif 3200 <= i: t += 1
    
minNum = 0
p = flag.count(True)
if p > 0: minNum = p
elif p == 0 and t > 0:
  minNum = 1
  minNum -= 1
  
maxNum = minNum + t

print(minNum,maxNum)
# Judge status: Accepted
N,P = list(map(int, input().split()))
a = list(map(int, input().split()))
num_odd = sum([i%2 == 1 for i in a])
num_even = N - num_odd

ce = 2 ** num_even
co = 2 ** (num_odd - 1)
if num_odd == 0:
    co = P^1
print(co * ce)
# Judge status: Accepted
r, g, b = input().split()

ans = int(r + g + b)
print('YES') if ans % 4 == 0 else print('NO')
# Judge status: Wrong Answer
S = int(input())
T = input()

if S <= 3200:
  print("Red")
else:
  print(T)
# Judge status: Wrong Answer
A,B=list(map(int,input().split()))
if(A>=B):
  num=A
else:
  num=B
i=2
while True:
  ans=num*i
  if(ans%A==0 and ans%B==0):
    print(ans)
    break
  i+=1
# Judge status: Accepted
a = input()
if a.islower():
  print("a")
else:
  print("A")
# Judge status: Accepted
a,b,c,d=map(int,input().split())
total=b-a+1
cdead=b//c-(a-1)//c
ddead=b//d-(a-1)//d
from fractions import gcd

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

z=lcm(c,d)
cddead=b//z-(a-1)//z
print(total-cdead-ddead+cddead)
# Judge status: Wrong Answer
inp = list(map(int,input().split(" ")))

location = inp[0]
times = inp[1]
distance = inp[2]

x = float(abs(location / distance))

if x >= times:
    print(abs(location - (times*distance)))
elif (times - int(x))%2 == 0:
    print(abs(location - abs(int(x)*distance)))
else:
    print(abs(location - abs(int(x)*distance)-distance))
# Judge status: Accepted
from fractions import gcd
from functools import reduce

def lcm(x, y):
  g = gcd(x, y)
  x //= g
  y //= g
  if x&y&1:
    l = x*y*g
    if l > 10**9:
      return 0
    return l
  return 0
n, m = map(int, input().split())
A = list(map(lambda x: int(x)//2, input().split()))
k = reduce(lcm, A)
if k == 0:
  print(0)
else:
  print(((m//k)+1)//2)
# Judge status: Accepted
s = input()
f = True

if s.find("S") != -1 and s.find("N") == -1:
    f = False
if s.find("S") == -1 and s.find("N") != -1:
    f = False
if s.find("E") != -1 and s.find("W") == -1:
    f = False
if s.find("E") == -1 and s.find("W") != -1:
    f = False
print("Yes" if f else "No")
# Judge status: Accepted
import math
def main():
    t = [int(t)for t in input().split()]
    w,h,x,y = t[0],t[1],t[2],t[3]

    print(w*h/2, 1 if w/2==x and h/2 ==y else 0)

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
x = int(input())
k = 1
while True:
    if k ** 5 - (k-1) ** 5 > x:
        break
    k += 1
print(k)
for a in range(k):
    amari = x - a ** 5
    for b in range(a+1):
        if amari == b ** 5:
            print(a, -b)
            break
        if amari == (-b) ** 5:
            print(a, b)
            break
# Judge status: Accepted
import math

N = int(input())

s = 0

for a in range(1, N+1):
    s += (N-1)//a

print(s)
# Judge status: Wrong Answer
import math

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

for i in range(len(A)):
    A[i] -= (i + 1)
# print(A)

average = math.ceil(sum(A) / len(A))

for i in range(len(A)):
    A[i] = abs(A[i] - average)

sadness = sum(A)

print(sadness)
# Judge status: Accepted
N=int(input())
B=list(map(int,input().split()))
A=[0]*(N+1)
a=B[-1]
A[N]=a
for i in range(N-2,-1,-1):
  if B[i]<a:
    A[i+1]=B[i]
  A[i]=B[i]
  a=B[i]
print(sum(A))
# Judge status: Accepted
n = int(input())
a = [int(i) for i in input().split()]
c = 0
for i in range(0,n,2):
    if a[i] % 2 == 1:
        c += 1
print(c)
# Judge status: Accepted
A = [1,3,5,7,8,10,12]
B = [4,6,9,11]
C = [2]
D,E = list(map(int,input().split()))
if D in A and E in A:
    print("Yes")
    exit()
elif D in B and E in B:
    print("Yes")
    exit()
elif D in C and E in C:
    print("Yes")
    exit()
print("No")
# Judge status: Accepted
def z(x):
  fives = 0
  for j in range(1, 60):
    bs = 2 * 5 ** j
    fives = fives + x // bs
  return fives
x = int(input())
print(z(x) if x % 2 == 0 else 0)
# Judge status: Wrong Answer
def argmax(lst):
  c = lst[0]
  idx = 0
  for i in range(len(lst)):
    if c < lst[i]:
      idx = i
      c = lst[i]
  return idx

D = int(input())
C = list(map(int, input().split()))
S = []
for i in range(D):
  S.append(list(map(int, input().split())))

for i in S:
  print(argmax(i))
# Judge status: Wrong Answer
s = int(''.join(input().split()))

if s % 4:
    print('No')
else:
    print('Yes')
# Judge status: Accepted
NK = input().split()
Pn = input().split()
for i in range(int(NK[0])):
    Pn[i] = int(Pn[i])
Pn.sort()
s = 0
for i in range(int(NK[1])):
    s += Pn[i]
print(s)
# Judge status: Accepted
n = int(input())
s = [input() for _ in range(n)]
ans = [[] for _ in range(n)]

for i in range(n):
     ans[i] = s[i]

ANS = set(ans)
print(len(ANS))
# Judge status: Accepted
from math import log
n, k = map(int, input().split())
print(int(log(n, k))+1)
# Judge status: Wrong Answer
N,M,X,Y = map(int,input().split())
li_x = list(map(int,input().split()))
li_y = list(map(int,input().split()))

li_x.append(X)
li_y.append(Y)

li_x = set(li_x)
li_y = set(li_y)

if max(li_x)>min(li_y):
    print("War")
elif max(li_x)<min(li_y):
    print("No war")
elif max(li_x)==min(li_y):
    print("War")
# Judge status: Accepted
import sys


# \n
def input():
    return sys.stdin.readline().rstrip()


def main():
    N = int(input())
    mod = 10 ** 9 + 7

    ans = pow(10,N,mod)
    ans -= 2 * pow(9,N,mod)
    ans %=mod
    ans += pow(8,N,mod)
    print(ans%mod)


if __name__ == "__main__":
    main()
# Judge status: Accepted
a,b,c=map(int,input().split())
if c>=a and b>=c:
    print('Yes')
else:
    print('No')