peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())

sys.setrecursionlimit(10 ** 9)


def main():
    D = INT()
    print("Christmas" + " Eve"*(25 - D))


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
#!/usr/bin/env pypy3

MODULUS = 10**9+7

N = int(input())

ret = pow(10, N, MODULUS)
ret -= 2*pow(9, N, MODULUS)
ret += pow(8, N, MODULUS)

print(ret)
# Judge status: Accepted
import math

url = "https://atcoder.jp//contests/abc057/tasks/abc057_c"

def main():
    x = int(input())
    ans, div = divmod(x, 11)
    ans *= 2
    ans += math.ceil(div/6)
    print(ans)

if __name__ == '__main__':
    main()
# Judge status: Accepted
X = int(input())
if X < 600:
    print(8)
elif X<800:
    print(7)
elif X<1000:
    print(6)
elif X<1200:
    print(5)
elif X<1400:
    print(4)
elif X<1600:
    print(3)
elif X<1800:
    print(2)
else:
    print(1)
# Judge status: Accepted
A,B = map(int,input().split())
if((A+B)%2==0):
  print((A+B)//2)
else:
  print("IMPOSSIBLE")
# Judge status: Accepted
N = int(input())
d = list(map(int, input().split()))
d.sort()

s, t = N//2-1, N//2

ans = d[t] - d[s]
print(ans)
# Judge status: Accepted
n,k = [int(x) for x in input().split()]
a = [0] * (n + 1)
for i in range(1,n+1):
  a[i] = a[i-1] + i
#print(a)
res = 0
for i in range(k,n+1):
  ma = a[n] - a[n-i]
  mi = a[i-1]
  res += ma - mi + 1
  #print(i,res,ma,mi)
res += 1
res %= 10 ** 9 + 7
print(res)
# Judge status: Accepted
import math
a, b = map(int, input().split())
x = math.ceil((a + b) / 2)

print(x)
# Judge status: Wrong Answer
from collections import Counter
mod = 998244353

n = int(input())
dl = list(map(int, input().split()))
c = Counter(dl)

if c[0]!=1:
    print(0)
    exit()

for x in range(max(dl)+1):
    if c[x]==0:
        print(0)
        exit()

res = 1
for x in range(max(dl)):
    res *= pow(c[x],c[x+1],mod)
    res %= mod

print(res)
# Judge status: Accepted
n = int(input())
if n%1000 > 0:
    print(1000-n%1000)
else:
    print(0)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
c=[0]*60
for aa in a:
  for i in range(60):
    if aa&(1<<i):c[i]+=1
ans=0
for i,cc in enumerate(c):
  ans+=cc*(n-cc)*2**i
  ans%=mod
print(ans)
# Judge status: Accepted
a, b = map(int, input().split())

ans = a
if a > b: ans -= 1
print(ans)
# Judge status: Accepted
from sys import stdin, stdout

def main():
    line = stdin.readline()
    parts = line.split()
    mes = int(parts[0])
    dia = int(parts[1])

    stdout.write(str(mes if dia>=mes else mes-1))

main()
# Judge status: Wrong Answer
n=int(input())
b=list(map(int,input().split()))
a=[]
a.append(b[0])
for i in range(1,n-1):
    if b[i]<b[i-1]:
        a[i-1]=b[i]
    a.append(b[i])
print(sum(a))
# Judge status: Accepted
a, b, c = map(int, input().split())

if a == b and a == c:
	if a % 2 == 1:
		print(0)
		exit()
	else:
		print(-1)
		exit()
	
ans = 0
s, t, u = 0, 0, 0
while a%2==0 and b%2==0 and c%2==0:
	s = b//2 + c//2
	t = a//2 + c//2
	u = a//2 + b//2
	a, b, c = s, t, u
	ans += 1
	
print(ans)
# Judge status: Accepted
#解説見た
n = int(input())
p = list(map(int, input().split()))
p.append(0)
ans = 0
for i in range(n):
    if p[i] == (i+1):
        p[i],p[i+1] = p[i+1], p[i]
        ans += 1

print(ans)
# Judge status: Accepted
from math import sqrt


def IsPrime(num):
    if num < 2:
        return True
    elif num == 2:
        return True
    elif num % 2 == 0:
        return False

    sqrtNum = sqrt(num)
    for i in range(3, int(sqrtNum) + 1, 2):
        if num % i == 0:
            return False

    return True


if __name__ == "__main__":
    x = int(input())

    for i in range(x, 10**5+4):
        if IsPrime(i):
            print(i)
            exit()
# Judge status: Wrong Answer
import itertools
a=int(input())
ct=0
b=list(map(int,input().split()))
n=list(range(len(b)))
c=list(itertools.permutations(n,2))
for i in range(len(c)):
    e=c[i][0]
    f=c[i][1]
    if b[e]+b[f]==abs(e-f):
        ct+=1
print(ct/2)
# Judge status: Wrong Answer
x=int(input())
def prime(n):
    for i in range(2, 100000):
        if n % i == 0:
            return False
        else:
            return True
while prime(x) == False:
    x += 1
print(x)
# Judge status: Accepted
A, B, C = list(map(int, input().split()))
if C-(A-B)<=0:
    print("0")
else:
    print(C-(A-B))
# Judge status: Accepted
import itertools

N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))

num_list = [i+1 for i in range(N)]

a = 1
for i in list(itertools.permutations(num_list)):
    if P==i:
        break
    else:
        a += 1
b = 1
for i in list(itertools.permutations(num_list)):
    if Q==i:
        break
    else:
        b += 1

if a-b>=0:
    print(a-b)
else:
    print(-a+b)
# Judge status: Wrong Answer
# coding: utf-8
from math import ceil
N, H = map(int, input().split())
li = []
atop = 0
for _ in range(N):
    a, b = map(int, input().split())
    atop = max(atop, a)
    li.append([a, b])
li.sort(key=lambda x: x[1], reverse=True)
# print(li)
ans = ceil(H/atop)
cnt = 0
for i in range(N):
    H -= li[i][1]
    if H < 0:
        break
    cnt += 1
    ans = min(ans, cnt + ceil(H/atop))
print(ans)
# Judge status: Accepted
a,b,t=map(int,input().split())
bis=0
time=0
while time+a<t+0.5:
    bis+=b
    time+=a
print(bis)
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
before = 10**3
ans = 0
for i in A:
    if i - before == 1:
        ans += C[before-1]
    before = i
ans += sum(B)
print(ans)
# Judge status: Accepted
N = int(input())
A = [int(v) for v in input().split()]

def gcd(v1, v2):
    if v2 == 0:
        return v1
    return gcd(v2, v1 % v2)

A.sort()
a1 = A[0]

for a2 in A[1:]:
    a3 = gcd(a1, a2)
    a1 = a1 * a2 // a3

v = a1
total = 0
for a in A:
    total += v // a 
#    while total > 1000000007:
#        total -= 1000000007

total %= 1000000007
print(total)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
ans = 0
mod = 1e9 + 7
s = sum(A) % mod

for i in range(N):
    s -= A[i]
    ans += A[i] * s
    ans = ans % mod
print(int(ans))
# Judge status: Accepted
x,a,b = [int(x) for x in input().split()]

if abs(x-a) > abs(x-b):
    print("B")
else:
    print("A")
# Judge status: Accepted
import collections
n = int(input())
a = [int(i) for i in input().split()]
dic = collections.defaultdict(int)

for i in range(n):
  dic[a[i]] += 1
ans = 0
ls = list(dic.keys())
ls.sort()
ans_ls = []

for i in range(len(ls)-1,-1,-1):
  if dic[ls[i]] >= 2:
    ans_ls.append(ls[i])
  if dic[ls[i]] >= 4:
    ans_ls.append(ls[i])
if len(ans_ls) < 2:
  print(0)
else:
  print(ans_ls[0] * ans_ls[1])
# Judge status: Accepted
a, b = input().split()
print(int(a)*(round(float(b)*100))//100)
# Judge status: Accepted
a,b=map(int,input().split())
s=input()
if len(s)==a+b+1 and s[a]=='-' and s.count('-')==1:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
N = int(input())
print(N * 800 - (N // 15) * 200 )
# Judge status: Accepted
n=int(input())
s=input()
m=0
if n%2==0:
    for i in range(n//2):
        if s[i]==s[i+n//2]:
            m+=1
print("Yes" if m==(n/2) else "No")
# Judge status: Accepted
import collections
n=int(input())
a=[]
for _ in range(n):
    a.append(input())
c=collections.Counter(a)
tmp=[]
for k,v in c.items():
    if v%2!=0: 
        tmp.append(k)
print(len(tmp))
# Judge status: Accepted
(a, b, c) = map(int, input().split())

ans = max(0, c - (a - b))
print(ans)
# Judge status: Accepted
def is_palindromic(N):
    N_reversed=list(str(N))
    N_reversed.reverse()
    N_reversed=int(''.join(N_reversed))
    if N_reversed==N:
        return True
    else:
        return False
A,B=map(int,input().split())
count=0
for i in range(A,B+1):
    if is_palindromic(i):
        count+=1
print(count)
# Judge status: Wrong Answer
N = int(input())
A = [int(x) for x in input().split()]
ans = 0
for i in range(N):
    count = 0
    for j in range(N):
        if A[i]%A[j] != 0 and i != j: 
            count += 1
            if count == N-1:
                ans += 1

print(ans)
# Judge status: Accepted
a, b, c = map(int, input().split())
if c - (a-b) < 0:
    print("0")
else:
    print(c-(a-b))
# Judge status: Accepted
mod = 10**9 + 7
n, a, b = map(int, input().split())

total = pow(2, n, mod)-1

def mod_comb(n,k,p):
    if n<0 or k<0 or n<k:
        return 0
    if n==0 or k==0:
        return 1
    a = 1
    b = 1
    for i in range(k):
        a = (a*((n-i)%p))%p
        b = (b*((i+1)%p))%p
    return (a*pow(b,p-2,p))%p

x = mod_comb(n, a, mod)
y = mod_comb(n, b, mod)
total = (total-x-y)%mod

print(total)
# Judge status: Accepted
s = ''.join(sorted(list(input())))
t = ''.join(sorted(list(input()), reverse=True))

if s < t:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
S=input()
T=input()
a=[]
for i in range(len(S)-len(T)+1) :
  count=0
  for j in range(len(T)) :
    if S[i:i+len(T)][j]==T[j] :
      count+=1
  a.append(count)
print(len(T)-max(a))
# Judge status: Accepted
N=int(input())
D=list(map(int,input().split()))
D.sort()

K=D[N//2]-D[N//2-1]

print(K)
# Judge status: Accepted
def main():
    S = input()
    L, R = 1001001, 0
    for i in range(len(S)):
        if S[i] == 'A' and L > i:
            L = i
        if S[i] == 'Z' and R < i:
            R = i
    print(R - L + 1)


if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
O=input()
E=input()

N=len(O)
M=len(E)
ans=""
for i in range(N):
    ans+=O[i]
    if N-M==1 and i==M-1:
        break
    ans+=E[i]
print(ans)
# Judge status: Accepted
S = input()

if S == "Sunny":
    print("Cloudy")

elif S == "Cloudy":
    print("Rainy")

else :
    print("Sunny")
# Judge status: Wrong Answer
S=input()

A=[0]*(len(S)+1)
for i in range(len(S)):
    if S[i]=='<':
        A[i+1]=max(A[i+1],A[i]+1)
    
for i in range(len(S)-1,0,-1):
    if S[i]=='>':
        A[i]=max(A[i],A[i+1]+1)

print(sum(A))
# Judge status: Wrong Answer
n = int(input())
w = [input() for i in range(n)]
if len(set(w)) == n:
    for i in range(1, n):
        s0 = list(w[i - 1])
        s1 = list(w[i])
        if s1[0] == s0[-1]:
            pass
        else:
            print("NO")
            exit()
    print("Yes")
else:
    print("No")
# Judge status: Accepted
s=int(input())
a=s//100
b=s-a*100
if a<13 and b<13 and a>0 and b>0:
    print("AMBIGUOUS")
elif a<13 and a>0:
    print("MMYY")
elif b<13 and b>0:
    print("YYMM")
else:
    print("NA")
# Judge status: Accepted
a,b,x = map(int,input().split())

ans = b//x - (a-1)//x 
print(ans)
# Judge status: Accepted
N = int(input())
CSF = []
import math
for i in range(N-1):
    CSF.append(list(map(int,input().split())))
def time(t,i):
    if CSF[i][1] >= t:
        return CSF[i][1]+CSF[i][0]
    else:
        x = math.ceil((t-CSF[i][1])/CSF[i][2])
        return CSF[i][1]+ x*CSF[i][2] + CSF[i][0]

for i in range(N-1):
    t = CSF[i][0]+CSF[i][1]
    for j in range(i+1,N-1):
        t = time(t,j)
    print(t)

print(0)
# Judge status: Wrong Answer
# 入力
n = int(input())
k = int(input())
x = int(input())
y = int(input())

# 処理
first_stay = k * x
second_stay = (n - k) * y
total = first_stay + second_stay

print(total)
# Judge status: Accepted
a=sorted(input().split())
print(a[0]*int(a[1]))
# Judge status: Accepted
a, b = map(int, input().split())

if a <= 8 and b <= 8:
  print("Yay!")
else:
  print(":(")
# Judge status: Accepted
n = int(input())
s = 0
for i in range(1, n+1):
    s += i
    if s >= n:
        break

k = s-n
ans = []
for j in range(1, i+1):
    if j == k:
        continue
    else:
        ans.append(j)
ans = list(map(str, ans))
print('\n'.join(ans))
# Judge status: Wrong Answer
import math
def resolve():
	n, k = map(int, input().split())
	a = list(map(int, input().split()))
	i = a.index(min(a))
	v = math.ceil(i/(k-1)) + math.ceil((n-1-i)/(k-1))
	print(v)
resolve()
# Judge status: Wrong Answer
a, b, n = map(int, input().split())
if n>=b:
    print(int(a*b/b) - a*int(b/b))
else:
    print(int(a*n/b) - a*int(n/b))
# Judge status: Wrong Answer
s = [input() for _ in range(3)]

d = {'a': 0, 'b': 1, 'c': 2}
nxt, cnt = 0, [0, 0, 0]
for _ in range(sum(len(si) for si in s)):
    now = nxt
    nxt = d[s[now][cnt[now]]]
    cnt[now] += 1
    if len(s[nxt]) <= cnt[nxt]:
        print(['A', 'B', 'C'][now])
        break
# Judge status: Accepted
LI = lambda: list(map(int, input().split()))

X, A, B = LI()


def main():
    x = B - A
    if x <= 0:
        ans = "delicious"
    elif x <= X:
        ans = "safe"
    else:
        ans = "dangerous"
    print(ans)


if __name__ == "__main__":
    main()
# Judge status: Accepted
n = int(input())
mod = 10 ** 9 + 7

dp = [0] * 2001
dp[3] = 1
dp[4] = 1
dp[5] = 1
if n >= 6:
    for i in range(6,n+1):
        dp[i] = (dp[i-1] + dp[i-3]) % mod
print(dp[n])
# Judge status: Accepted
n,m=map(int,input().split())
low=1
high=n 
for _ in range(m):
    l,r=map(int,input().split())
    low=max(l,low)
    high=min(r,high)
if high-low+1>=0:
    print(high-low+1)
else:
  print(0)
# Judge status: Accepted
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

a = i()
print(a+a**2+a**3)
# Judge status: Wrong Answer
a,b,x = map(int,input().split())
import numpy as np
if x<=(a*a*b)/2:
    A = 2*x/(a*b*b)
    Z = A
    print(np.arctan(Z)*180/(np.pi))
else:
    A = 2*a*a*b-2*x
    B = A/(a*a*a)
    Z = B
    print(np.arctan(Z)*180/np.pi)
# Judge status: Accepted
N = int(input())
l = []
for i in range(N):
    l.append(input())
AC = l.count('AC')
WA = l.count('WA')
TLE = l.count('TLE')
RE = l.count('RE')
print("AC x {}".format(AC))
print("WA x {}".format(WA))
print("TLE x {}".format(TLE))
print("RE x {}".format(RE))
# Judge status: Wrong Answer
n = int(input())
s = str(input())
t = str(input())
if s == t:
    print(n)
else:
    for i in range(1, n):
        l = s[:i + 1] + t
        if l[:n] == s:
            print(len(l))
            break
# Judge status: Wrong Answer
x, k, d = list(map(int, input().split()))

x = abs(x)
p = 0

if(x - k*d >=0):
  p = x - k*d

else:
    p = x%d
    if (k - x/d)%2 == 1:
        p = p-d
print(abs(p))
# Judge status: Wrong Answer
N = int(input())
Bs = list(map(int, input().split()))

As = [Bs[0]]
As.extend(Bs)

#print(Bs)
#print(As)

for index, B in enumerate(Bs[1:]):
    if B < As[index]:
        As[index] = B

print(sum(As))
# Judge status: Accepted
from bisect import bisect_right
a, b = (int(x) for x in input().split())
if a <= 0 and 0 <= b: #0を含む
  print('Zero')
elif 0 < a and 0 < b: #すべて正
  print('Positive')
else: #すべて負
  print('Positive' if (b - a + 1)%2 == 0 else 'Negative')
# Judge status: Accepted
N = input()

ans = 'No' if 'AAA'==N or 'BBB'==N else 'Yes'
print(ans)
# Judge status: Wrong Answer
L, R = map(int,input().split())
print((100**L)*int((R-1)/99)+R)
# Judge status: Wrong Answer
x = int(input())

if x > 11:
    if x % 11 == 0:
        print(int(x*2/11))
    else:
        print(int(x*2/11)+1)

elif x < 7:
    print(1)
    
else:
    print(2)
# Judge status: Wrong Answer
from sys import stdin

n,c,k = [int(x) for x in stdin.readline().rstrip().split()]
li = [int(stdin.readline().rstrip()) for _ in range(n)]+[10**10]
li.sort()

time = li[0]
bus = 0
hito = 0

for i in li:
    hito += 1
    if i-time > k or hito > c:
        bus += 1
        hito = 0
        time = i
print(bus)
# Judge status: Accepted
a=int(input())
print(a**2+a+a**3)
# Judge status: Accepted
#普通にソートしてから、配列のK個づつ区切ってパターンを調べればN - K + 1回の比較で行ける

N, K = map(int, input().split())
h = [int(input()) for _ in range(N)]
h.sort()

distances = [h[i + K -1] - h[i] for i in range(N -K + 1)]
ans = min(distances)
print(ans)
# Judge status: Wrong Answer
s= input ("please enter the day")
if s == "SAT" :
    print ("1 \n It is Saturday today, and tomorrow will be Sunday")
elif s == "SUN" :
    print ("7 \n It is Sunday today, and seven days later, it will be Sunday again.")
elif s == "MON" :
    print (" 6 \n It is monday today, and six days later, it will be Sunday again.")
elif s == "TUE" :
    print (" 5 \n It is thusday today, and five days later, it will be Sunday again.")
elif s =="WED" :
    print (" 4 \n It is wednsday today, and four days later, it will be Sunday again.")
elif s == "THU" :
    print ("3 \n It is thusday today, and three days later, it will be Sunday again.")
else:
    print ("2 \n It is friday today, and two days later, it will be Sunday again.")
# Judge status: Accepted
import collections

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

sum = []
for i in a:
  sum.append(i)
  sum.append(i+1)
  sum.append(i-1)
print(collections.Counter(sum).most_common()[0][1])
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
asum = sum(a)
amax = max(a)
if amax < asum-amax:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 10**9 + 7

    a = [int(input()) for _ in range(5)]
    k = int(input())
    if a[-1]-a[0] > k:
        print(':(')
    else:
        print('Yay!')

if __name__ == '__main__':
    main()
# Judge status: Accepted
n = int(input())
di = [[0]*9 for _ in range(9)]
for i in range(1, n+1):
    p = list(str(i))
    if p[-1] == '0':
        continue
    di[int(p[0])-1][int(p[-1])-1]+=1
result = 0
for i in range(9):
    for j in range(9):
        c = di[i][j]
        d = di[j][i]
        result+=c*d
print(result)
# Judge status: Accepted
N = int(input())

if N % 10 in [2, 4, 5, 7, 9]:
    print('hon')
elif N % 10 in [0, 1, 6, 8]:
    print('pon')
elif N % 10 in [3]:
    print('bon')
# Judge status: Accepted
N = int(input())
d = list(sorted(map(int, input().split())))
c = len(d)//2
print(d[c]-d[c-1] if d[c]!=d[c-1] else 0)
# Judge status: Wrong Answer
X,N=[int(x) for x in input().split(" ")]
if N==0: print(X)
else:
    a=[int(x) for x in input().split(" ")]
    i=1
    res=0
    if not X in a:
        res=X
    while True:
        X+=i*(-1)**i
        if not X in a:
            res=X
            break
        i+=1
    print(res)
# Judge status: Wrong Answer
N, A, B = map(int, input().split())

if A > B:
  print(0)
  exit()

if A == B:
  if N == 1:
    print(1)
    exit()
  else:
    print(0)
    exit()

print((N-2)*(B-A)+1)
# Judge status: Wrong Answer
S = input()
temp = ["a", "b", "c"]
abc = [S.count(x) for x in temp]
abc.sort(reverse=True)
if abc.count(0) > 0:
    print("No")  
elif abc[0] == abc[1] == abc[2]:
    print("YES")
elif abc[0] == abc[1] == abc[2]+1:
    print("YES")
elif abc[0] == abc[1]+1 == abc[2]+1:
    print("YES")
else:
    print("No")
# Judge status: Wrong Answer
n = int(input())

# a進法でのnの桁和
def func(n,a):
    res = 0
    while n > 0:
        res += n%a
        n //= a
    return res

mini = 10**6

for i in range(n):
    tmp = func(i,6) + func(n-i,9)
    mini = min(mini,tmp)
print(mini)
# Judge status: Wrong Answer
N,M = [int(i) for i in input().split()]
a = []
for i in range(N):
	array = input()
	a.append(array)
b = []
for i in range(M):
	line = input()
	b.append(line)
for i in range(N-M+1):
	for j in range(N-M+1):
		ans = 'Yes'
		for n in range(M):
			for m in range(M):
				if a[i+n][j+m] == b[n][m]:
					pass
					#print(i,j,n,m)
				else:
					ans = 'No'
print(ans)
# Judge status: Accepted
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
print('No') if(A[M - 1] < sum(A) / (4 * M)) else print('Yes')
# Judge status: Accepted
n, r = map(int, input().split())

if n < 10: print(100*(10-n)+r)
else: print(r)
# Judge status: Accepted
S, T = [0] * 26, [0] * 26

for s in input():
    S[ord(s) - ord('a')] += 1
for t in input():
    T[ord(t) - ord('a')] += 1
S.sort()
T.sort()
ans = 'Yes' if S == T else 'No'
print(ans)
# Judge status: Accepted
import math

n, k = map(int, input().split())
[int(i) for i in input().split()]
print(math.ceil((n-k) / (k - 1) + 1))
# Judge status: Wrong Answer
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd # 最大公約数
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) # 最小公倍数
# list(map(int, input().split()))

a, b, c = map(int, input().split())
k = int(input())

for _ in range(k):
    if a > b:
        b *= 2
    else:
        c *= 2

if a < b < c:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n,m = map(int,input().split())
ans = 0
ans += n*(n-1)//2
ans += m*(m-1)//2
print(ans)
# Judge status: Wrong Answer
A, B = map(int, input().split())
print(A+B -24*((A+B)//24) if A+B > 24 else A+B)
# Judge status: Wrong Answer
def main():
    s = int(input())
    a_set = set()
    a = s
    for i in range(1, 1000000):
        if a % 2 == 0:
            a = a // 2
        else:
            a = a * 3 + 1
        if a in a_set:
            print(i + 1)
            exit()
        a_set.add(a)


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

import collections
n = int(input())
s = list(input())

ans = 1
c = collections.Counter(s)
for i in set(s):
    ans *= (c[i] + 1)
print((ans - 1) % (pow(10, 9) + 7))
# Judge status: Wrong Answer
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys

# import itertools
# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A, B, K = map(int, readline().split())
ans=''
if B - A <= 2 * K:
    ans += '\n'.join(str(x) for x in range(A, B + 1))
else:
    ans += '\n'.join(str(x) for x in range(A, A + K))
    ans+='\n'
    ans += '\n'.join(str(x) for x in range(B + 1 - K, B + 1))
print(ans)
# Judge status: Accepted
from fractions import gcd

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

l = [0]*(n+1)
r = [0]*(n+1)

for i in range(n):
    l[i+1] = gcd(l[i], a[i])
    r[n-i-1] = gcd(r[n-i], a[n-i-1])

m = [0]*n

for i in range(n):
    m[i] = gcd(l[i], r[i+1])

print(max(m))
# Judge status: Accepted
N = int(input())
A = list()
for i in range(N-1):
  A.append(list(map(int, input().split())))
for i in range(N):
  ans = 0
  j = i
  while(j < N-1):
    C = A[j][0]
    S = A[j][1]
    F = A[j][2]
    
    if(S > ans):
      ans = S
    else:
      if(ans % F != 0):
        ans = ((ans//F)+1)*F
    ans += C
    j += 1
    
  print(ans)
# Judge status: Wrong Answer
n,k,q=map(int,input().split())
lst=[0]*n
for i in range(q):
  person=int(input())
  lst[person-1]+=1
for p in range(n):
  temp=k-q+lst[p-1]
  if temp<=0:
    print("No")
  else:
    print("Yes")
# Judge status: Accepted
N = int(input())
l = [int(input()) for i in range(N)]
index = 0
count = 0
for j in range(N):
    index = l[index] - 1
    count += 1
    if index == 1:
        print(count)
        exit()
print(-1)
# Judge status: Accepted
n, k = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]

ans = (n - 1) // (k - 1)
if (n - 1) % (k - 1) != 0:
    ans += 1
print(ans)
# Judge status: Accepted
n,t=map(int,input().split())
ct=[]
ans=[]
for i in range(n):
    ct=[int(x) for x in input().split()]
    if ct[1] <=t:
        ans.append(ct[0])
if ans==[]:
    print("TLE")
else:
    print(min(ans))