peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
import sys
list = input().split(" ")
N = int(list[0])
Y = int(list[1])

for yukichi in range(0,N+1):
    for ichiyo in range(0,N - yukichi):
        hideyo = N - yukichi - ichiyo
        if 10000*yukichi + 5000*ichiyo + 1000*hideyo == Y:
            print(yukichi,ichiyo,hideyo)
            sys.exit()
 
print(-1,-1,-1)
# Judge status: Wrong Answer
n, m = map(int, input().split())
s = "0" * n
flag = 0

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

    if s[a - 1] != '0':
        if s[a - 1] != str(b):
            flag = 1
    
    s = s[:a-1] + str(b) + s[a:]

if flag == 0:
    if n == 1:
        print(s)
    elif int(s) >= 10 ** (n - 1):
        print(s)
    else:
        print(-1)
else:
    print(-1)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))

bitsum = [0 for _ in range(60)]
for x in a:
    for i in range(60):
        bitsum[i] += bool(x & (1 << i))

ans = 0
for x in a:
    for i in range(60):
        k = bitsum[i]
        if (x & (1 << i)):
            k = n - k
        ans += k << i
print(ans//2)
# Judge status: Accepted
n=int(input())
P=[]
M=[]
for i in range(n):
    x,y=map(int,input().split())
    P.append(x+y)
    M.append(x-y)
dP=abs(max(P)-min(P))
dM=abs(max(M)-min(M))
print(max(dP,dM))
# Judge status: Accepted
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7



def main():
    int1 = lambda x: int(x) - 1
    N, A, B, C, D = map(int1, input().split())
    S = input()

    if "##" not in S[A:B + 1] and "##" not in S[C:D + 1]:
        if C > D and "..." not in S[B - 1:D + 2]:
            print("No")
        else:
            print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
o = []

for i in range(n)[::-2]:
    o.append(a[i])

for i in range(n)[n%2::2]:
    o.append(a[i])
print(*o)
# Judge status: Wrong Answer
import bisect
n = int(input())
X = sorted(list(map(int,input().split())), reverse=True)
Y = sorted(list(map(int,input().split())), reverse=True)
Z = sorted(list(map(int,input().split())), reverse=True)
print(sum(bisect.bisect_right(X,b) * (n-bisect.bisect_left(Z,b))) for b in Y)
# Judge status: Accepted
a = [int(i) for i in input().split()]
k = int(input())
a.sort()
note = a[2]
for i in range(k):
	note *= 2
print(a[0] + a[1] + note)
# Judge status: Accepted
n = int(input())
l = [0] * (10**5)
N = 10**4

for i in range(1, 10**2+1):
    for j in range(1, 10**2+1):
        for k in range(1, 10**2+1):
            a = i*i + j*j + k*k + i*j + j*k + k*i
            l[a] += 1

for i in range(n):
    print(l[i+1])
# Judge status: Wrong Answer
n=input()
k=input()
x=input()
y=input()
print (k*x) + (n-k)*y
# Judge status: Wrong Answer
N= int(input())
a = [input().split() for i in range(N)]

Is = []
for i in range(N):
    Ds = a[i]
    if Ds[0] == Ds[1]:
        Is.append(i)

Boooo = False
for i in range(len(Is)-2):
    if Is[i] == Is[i+1] and Is[i+1] == Is[i+2]:
        Boooo = True

if Boooo:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
str1=input()
str5="es"
str6='s'
if(str1[-1]!='s'):
  str2=str1[0:]+str6[0:]
else:
  str2=str1[0:]+str5[0:]
print(str2)
# Judge status: Accepted
N, X, Y = map(int, input().split())

X -= 1
Y -= 1

output = [0]*N

for i in range(N-1):
  for j in range(i+1, N):
    output[min((j-i), abs(i-X)+1+abs(j-Y))] += 1
    
for i in range(1, N):
  print(output[i])
# 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(n-1):
    if a[i] + a[i+1] > x:
        temp = a[i] + a[i+1] - x
        ans += temp
        a[i+1] -= temp
print(ans)
# Judge status: Wrong Answer
s = input()
t = input()

print(s)
print(t[0:-1])

if s == t[0:-1]:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
N = int(input())
X = list(map(int, input().split()))
P = sum(X)//N
ans1 = 0
ans2 = 0
for x in X:
    ans1 += (P-x)**2
    ans2 += (P+1-x)**2
print(min(ans1, ans2))
# Judge status: Accepted
a,b = map(int,input().split())
c = abs(b - a)
x = 0
for i in range(1,c+1):
  x += i
print(x-b)
# Judge status: Accepted
N = int(input())
a = list(map(int,input().split()))
total = sum(a)
ans = float('inf')
x = 0
for i in range(N-1):
    x += a[i]
    ans = min(abs(total-2*x),ans)
print (ans)
# Judge status: Accepted
x = int(input())

per11 = x // 11
remain_per11 = x % 11

if remain_per11 >= 7:
    print(per11*2 + 2)
elif remain_per11 == 0:
    print(per11*2)
else:
    print(per11*2 + 1)
# Judge status: Accepted
def resolve():
    A, B, C = list(map(int, input().split()))
    print(min(C, B//A))

if '__main__' == __name__:
    resolve()
# Judge status: Wrong Answer
import sys
inf = 10**15
mod = 10**9+7
n, y = map(int, input().split())
ans=0
A = y//10000
for i in range(A+1):
    restY = y-i*10000
    restN = n-i
    if restY >= 0 and restN >= 0:
        B = restY//5000
        for j in range(B+1):
            restY = restY-j*5000
            restN = restN-j
            if restN>=0 and restY == restN*1000:
                print('{} {} {}'.format(i,j,restN))
                sys.exit()
print('{} {} {}'.format(-1,-1,-1))
# Judge status: Wrong Answer
A,B,C=map(int,input().split())
ichi=10*A+B+C
two=A+10*B+C
three=C*10+A+B
print(max(ichi,two))
# Judge status: Accepted
import sys

def main():
    n = int(input())
    s = [x.rstrip() for x in sys.stdin.readlines()]
    alphabet = "abcdefghijklmnopqrstuvwxyz"

    for c in alphabet:
        minc = 10**10
        for x in s:
            cnt = x.count(c)
            minc = min(cnt, minc)
        print(c*minc, end="")

if __name__ == '__main__':
    main()
# Judge status: Accepted
N=int(input())
a=list(map(int,input().split()))
res=0
count=[0]*(10**5+2)
for i in range(N) :
  count[a[i]]+=1
for i in range(10**5) :
  x=count[i]+count[i+1]+count[i-1]
  res=max(res,x)
print(res)
# Judge status: Accepted
N, D = [int(s) for s in input().split()]
print(N // (2 * D + 1) + (N % (2 * D + 1) != 0) )
# Judge status: Accepted
a, b, c = map(int,input().split())

i = 3
if a==b:
    i-=1
if b==c:
    i-=1
if c==a:
    i-=1
if not i:
    i=1
print(i)
# Judge status: Accepted
c = str(input())
if c in "aiueo":
  print("vowel")
else:
  print("consonant")
# Judge status: Accepted
d, t, s = map(int, input().split())
if s * t >= d:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
a,b = map(int, input().split())
mafs = 0 
if a < 1 and b >=0:
  print("Zero")
elif a > 0 and b > 0:
  print("Positive")
elif a < 0 and b < 0:
    if (abs(a) - abs(b) + 1) % 2 == 0: print("Positive")
    else: print("Negative")
# Judge status: Accepted
N = int(input())
a = [list(map(int, input().split())) for _ in range(N)]
a.insert(0, [0, 0, 0])
dp = [[0, 0, 0] for _ in range(N+1)]
for i in range(1, N + 1):
    for j in range(3):
        for k in range(3):
            if j != k:
                dp[i][j] = max(dp[i][j], a[i][j] + dp[i - 1][k])
print(max(dp[-1]))
# Judge status: Accepted
s = input()
if s in ['AAA', 'BBB']:
  print('No')
else:
  print('Yes')
# Judge status: Accepted
n = int(input())
list = [[int(j) for j in input().split()] for _ in range(n)]
ans = 0
for i in range(n):
    for j in range(n):
        ans += ((list[i][0] - list[j][0]) ** 2 + (list[i][1] - list[j][1]) ** 2) ** 0.5
print(ans / n)
# Judge status: Accepted
x = int(input())
if x >= 30:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N = int(input())
if N==25:print("Christmas")
elif N==24:print("Christmas Eve")
elif N==23:print("Christmas Eve Eve")
else : print("Christmas Eve Eve Eve")
# Judge status: Wrong Answer
A,B,C,X,Y = list(map(int, input().split()))

ans1 = 0
ans2 = 0
ans3 = 0

# 通常のケース
ans1 = A * X + B * Y

# 半分のケース
if X >= Y:
    ans2 = Y * 2 * C + (X - Y) * A
    if Y * 2 > X:
        ans3 = X * 2 * C
else:
    ans2 = X * 2 * C + (Y - X) * A
    if X * 2 > Y:
        ans3 = Y * 2 * C

print(min(ans1,ans2,ans3))
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

cnt_4, cnt_2 = 0, 0
for num in a:
    if num % 4 == 0:
        cnt_4 += 1
    elif num % 2 == 0:
        cnt_2 += 1

if n//2 <= cnt_4 + cnt_2//2:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
n = int(input())
ans=""
if n == 0:
    print(0)
    exit()
while n:
    if n % 2 != 0:
        ans += "1"
        n -= 1
    else:
        ans += "0"
    n //= -2
print(ans[ : : -1])
# Judge status: Accepted
n = int(input())
s = input()
x = 0
ans = 0
for i in range(n):
    if s[i] == 'I':
        x += 1
        ans = max(ans, x)
    elif s[i] == 'D':
        x -= 1
print(ans)
# Judge status: Accepted
n=int(input())
print(800*n-200*(n//15))
# Judge status: Wrong Answer
import sys
readline = sys.stdin.readline

N,*A = map(int,open(0).read().split())
A += [0]
ans = 0
for i in range(len(A)):
  if A[i] % 2 == 1 and A[i + 1] % 2 == 1:
    A[i] += 1
    A[i + 1] -= 1
  ans += A[i] // 2
  
print(ans)
# Judge status: Accepted
D = int(input())
print("Christmas"+" Eve"*(25-D))
# Judge status: Accepted
X = int(input())
dp = [0] * (X + 1000)
dp[0] = 1
array = [100, 101, 102, 103, 104, 105]

for x in range(X):
    for y in array:
        if dp[x] == 1:
            dp[x + y] = 1
print(dp[X])
# Judge status: Accepted
a, b = map(int, input().split())
n = min(a, b)

m = max(a, b)

if n == 1 and m == 1:
    print(1)
elif n == 1:
    print(m-2)
else:
    print((n-2)*(m-2))
# Judge status: Wrong Answer
N = int(input())

for i in range(1,10):
    if N % i != 0:
        print("No")
    elif N / i < 10:
        print("Yes")
    else:
        print("No")
# Judge status: Accepted
K = int(input())

count = 1
m = 7 % K
s = set()
while 1:
    if m == 0:
        print(count)
        break
    if m in s:
        print(-1)
        break
    count += 1
    s.add(m)
    m = (m * 10 + 7) % K
# Judge status: Wrong Answer
k, s = map(int, input().split())
ans = 0
for x in range(k):
    for y in range(k):
        for z in range(k):
            if s == x+y+z:
                ans += 1
print(ans)
# Judge status: Accepted
N = int(input())
As = list(map(int, input().split()))

isOKs = [False] * (N+1)
isOKs[0] = True
for A in As:
    if isOKs[A-1]:
        isOKs[A] = True

for A in reversed(range(1, N+1)):
    if isOKs[A]:
        print(N-A)
        break
else:
    print(-1)
# Judge status: Accepted
from fractions import gcd
n = int(input())
A = list(map(int, input().split()))
ans = 0
l = [A[0]]
r = [A[n-1]]
for i in range(1, n):
    l.append(gcd(l[i-1], A[i]))
    r.append(gcd(r[i-1], A[n-i-1]))
r.reverse()
# print(l, r)
for i in range(n):
    if i == 0:
        cost = r[1]
    elif i == n-1:
        cost = l[n-2]
    else:
        cost = gcd(l[i-1], r[i+1])
    if ans < cost:
        ans = cost

print(ans)
# Judge status: Wrong Answer
N, K = map(int,input().split())
A = list(map(int,input().split()))
Are = list(set(A))
if len(Are) <= K:
  print(0)
  exit()
else:
  B = []
  for i in range(len(Are)):
    B.append(A.count(Are[i]))
  B.sort()
  for i in range(len(B)):
    if i+1 >= len(Are)-K:
      print(sum(B[:i+1]))
      break
print(B)
# Judge status: Accepted
N, T = map(int, input().split())
ans = 10 ** 9
for i in range(N):
    c, t = map(int, input().split())
    if T >= t:
        ans = min(ans, c)
if ans != 10 ** 9:
    print(ans)
else:
    print("TLE")
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))

M = 1000
for i in range(N-1):
    if A[i] < A[i+1]:
      have = M // A[i]
      rest = M % A[i]
      M = have*A[i+1]+rest
      
print(M)
# Judge status: Accepted
n = int(input())
import math
start = math.floor(math.sqrt(n))
for i in reversed(range(start+1)):
    if i == 0:
        i = n
    else:
        if n/i == int(n/i):
            break
print(i+n//i-2)
# Judge status: Accepted
L,R,d=list(map(int,input().split()))
count = 0
for i in range(L,R+1):
  if i%d==0:
    count+=1
print(count)
# Judge status: Accepted
from itertools import groupby
n = int(input())
a = list(map(int,input().split()))
b = [i + 1 == j for i, j in enumerate(a)]
res = 0
for k, v in groupby(b):
    if not k:continue
    vv = len(list(v))
    res += (vv + 1) // 2
print(res)
# Judge status: Wrong Answer
N = int(input())

if N%2==0:
    print("0.5000000000")
else:
    print("0.6000000000")
# Judge status: Accepted
n, y = [int(i) for i in input().split()]
a, b, c, f = 0, 0, 0, 0

for i in range(n+1):
  for j in range(n+1):
    k = (y - 10000*i - 5000*j)/1000
    if k == n-i-j and k>=0:
      a, b, c = i, j, k
      f += 1
      break
      
if f == 0:
  print(-1,-1,-1)
else:
  print(int(a), int(b), int(c))
# Judge status: Accepted
"""
author : halo2halo
date : 22, 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)

N, T = map(int, readline().split())
ans = 10000
for _ in range(N):
    c, t = map(int, readline().split())
    if c <= ans and t <= T:
        ans = c

print("TLE" if ans == 10000 else ans)
# Judge status: Wrong Answer
print("Im"*(sum(map(int,input().split()))%3>0)+"Possible")
# Judge status: Accepted
A,B,C,D = map(int,input().split())

if min(B,D)<max(A,C):
    print(0)
else:
    print(min(B,D)-max(A,C))
# Judge status: Wrong Answer
def solve(string):
    import numpy
    from itertools import product
    n, m, x, *ca = map(int, string.split())
    ca = numpy.array(ca).reshape((-1, m + 1)).T
    c, a = ca[0], ca[1:]
    ans = n * 10**5
    for b in product([0, 1], repeat=n):
        b = numpy.array(b)
        if (a @ b.T).min() >= x:
            ans = min(ans, c @ b.T)
    return str(ans if ans < n*10**5 else -1)


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))
# Judge status: Accepted
import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,M = LI()
a = set([I() for _ in range(M)])
dp = [0]*(N+1) #1_indexed
dp[0] = 1
dp[1] = 1
for i in range(N+1):
    if i in a:
        dp[i] = 0
        continue
    if i-2>=0:
        dp[i] = (dp[i-1]+dp[i-2])%(10**9+7)
print(dp[-1])
# Judge status: Accepted
N, Q = map(int, input().split())
S = input()
T = [0]*(N+1)

for i in range(1, N):
    T[i+1] = T[i] + (1 if S[i-1:i+1]=='AC' else 0)
ans = []
for _ in range(Q):
    l, r = map(int, input().split())
    ans.append(T[r] - T[l])
print(*ans, sep='\n')
# Judge status: Wrong Answer
H, W = map(int, input().split())
total = H*W
if total % 2 == 0:
    ans = total//2
else:
    total += 1
    ans = total//2
print(ans)
# Judge status: Accepted
A = int(input())
B = int(input())
C = int(input())
X = int(input())

total = 0
for i in range(A+1):
    for j in range(B+1):
        for k in range(C+1):
            Ans = 500*i + 100*j + 50*k
            if Ans == X:
                total +=1
print(total)
# Judge status: Accepted
s=input()
a=753
ans=999
for i in range(len(s)-2):
  n=int(s[i:i+3])
  tmp=abs(a-n)
  if tmp<ans:
    ans=tmp
print(ans)
# Judge status: Accepted
S = input()
ans = []
for i in range(len(S)-2):
    ans.append(abs(753 - int(S[i:i+3])))
print(min(ans))
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
square = []
s1= a[0]
c = 0
result = 0
for i in range(1, n):
    s2 = a[i]
    if s1 == s2:
        c += 1
        if c % 2 == 1:
            square.append(s1)
            if len(square) == 2:
                result = square[0] * square[1]
                break
    else:
        s1 = a[i]
        c = 0
print(result)
# Judge status: Accepted
N = int(input())

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

if max(L)<sum(L)-max(L):
  print('Yes')
else:
  print('No')
# Judge status: Wrong Answer
N = int(input())
L = list(map(int,input().split()))
M = max(L)
ans = 0

for i in range(1,M):
  cnt = 0
  for j in range(len(L)):
    if i == L[j]-1 or i == L[j] or i == L[j]+1:
      cnt += 1
      if cnt > ans: ans = cnt
print(ans)
# Judge status: Accepted
n = int(input())
A = list(map(int,input().split()))
ans = 10**9
for i in range(-100,101):
    a = 0
    for j in A:
        a += (j-i)**2
    ans = min(ans,a)
print(ans)
# Judge status: Wrong Answer
N = int(input())

ans = 0

for i in range(N):
    if i % 3 !=0 and i % 5 != 0:
       ans += i

print(ans)
# Judge status: Wrong Answer
S=input()
T=input()
count=0
for i in range(len(S)):
  if S[i]==T[i]:
    count+=1
print(count)
# Judge status: Accepted
from collections import *
n=int(input())
l=list(map(int,input().split()))
d=defaultdict(int)
for i in l:
    d[i]+=1
c=0
for i in d:
    if(i!=d[i]):
        if(d[i]>i):
            c+=d[i]-i
        else:
            c+=d[i]
print(c)
# Judge status: Accepted
N,K = map(int,input().split())
l = list()
for i in range(K,N+2):
    min = i*(i - 1)/2
    max = (2*N - i + 1)*i /2
    cases = max - min + 1
    l.append(cases)
print(int(sum(l)) % (10**9 + 7))
# Judge status: Accepted
def solve(string):
    a, b, k = map(int, string.split())
    return "{} {}".format(max(0, a - k), max(0, min(b, a + b - k)))


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))
# Judge status: Accepted
a,b = map(int,input().split())
print((a+b)%24)
# Judge status: Wrong Answer
X = list(map(int, input().split()))
sx = X[0]
sy = X[1]
tx = X[2]
ty = X[3]
x = tx - sx
y = ty - sy
print(x, y)
l1 = "U" * y + "R" * x
l2 = "D" * y + "L" * x
l3 = "L" + "U" * (y + 1) + "R" * (x + 1) + "D"
l4 = "R" + "D" * (y + 1) + "L" * (x + 1) + "U"
print(l1 + l2 + l3 + l4)
# Judge status: Accepted
D = int(input())
for i in range(D):
  print(i%26+1)
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline

def main():
    N, K = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]

    x = A.index(1)
    l = -((-x) // (K - 1))
    lmod = (x + 1) % K
    r = -(-(N - x - 1 - lmod) // (K - 1))
    print(l + r)




if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
import sys
from collections import Counter
n = int(input())
a_ls = [int(i) for i in sys.stdin.readline().split()]
ct = Counter(a_ls)
ct = [(i, j) for i, j in sorted(ct.items(), key=lambda x:x[0], reverse=True) if j > 1]
if len(ct) < 2:
    print(0)
else:
    print(ct[0][0] * ct[1][0])
# Judge status: Accepted
from math import gcd
N=int(input())
A=list(map(int,input().split()))
L=[0]
R=[0]
for i in range(N):
  L.append(gcd(L[i],A[i]))
  R.append(gcd(R[i],A[-i-1]))
R=R[::-1]
P=0
for i in range(N):
  P=max(P,gcd(L[i],R[i+1]))
print(P)
# Judge status: Wrong Answer
N = int(input())
a = 0
if N >= 1000:
    a = N - 1000
else:
    a = a
while a >= 1000:
    a = a - 1000
if a != 0:
    a = 1000 - a
print(a)
# Judge status: Accepted
N = int(input())
now = [0,0]
tnow = 0
ans = 'Yes'
for i in range(N):
    t,x,y = map(int,input().split())
    dis = abs(x-now[0]) + abs(y-now[1])
    if t-tnow >= dis and (t-tnow)%2 == dis%2:
        tnow = t
        now = [x,y]
    else:
        ans = 'No'
        break
print(ans)
# Judge status: Accepted
L = []
for i in range(5):
    L.append(int(input()))

L1 = [x for x in L if x%10 == 0]
L2 = [x for x in L if x%10 != 0]
L3 = [(x%10,x//10) for x in L2]

ans = sum(L1)
if len(L3)>0:
  L3.sort(reverse = True)
  for i in range(len(L3)-1):
    ans += (L3[i][1]+1)*10
  ans += L3[-1][1]*10+L3[-1][0]
print(ans)
# Judge status: Accepted
n, k = map(int, input().split())
h = [int(input()) for i in range(n)]
h.sort()
ans = h[n-1]
for i in range(n-k+1):
  if ans > (h[i+k-1]-h[i]):
    ans = h[i+k-1]-h[i]
print(ans)
# Judge status: Accepted
a = input()

print('Good' if a[0] != a[1] !=a[2] !=a[3]  else 'Bad')
# Judge status: Accepted
#A - Hitachi String
S = list(input())
count = 0
if len(S) % 2 == 1:
    print("No")
    exit()
else:

    for i in range(0,int(len(S)//2),2):
        if S[i]+S[i+1] == "hi":
            pass
        else:
            print("No")
            exit()

    print("Yes")
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
count = {}
for i in a:
  if i in count:
    count[i] += 1
  else:
    count[i] = 1
edges = []
for i,j in count.items():
  if j >= 2:
    edges.append(i)
  if j >= 4:
    edges.append(i)

edges.sort(reverse=True)
if len(edges)<2:
  print(0)
else:
  print(edges[0]*edges[1])
# Judge status: Accepted
n = int(input())
print(n*(n+1)//2)
# Judge status: Accepted
L = int(input())

volume = (L / 3)**3

print(volume)
# Judge status: Accepted
n, a, b = map(int, input().split())
s = input()
a_n = 0
b_n = 0
for i in range(len(s)):
  m = s[i:i+1]
  if(m == "a"):
    if(a_n + b_n < a + b):
      print("Yes")
      a_n += 1
    else:
      print("No")
  elif(m == "b"):
    if((a_n + b_n < a + b) and (b_n < b)):
      print("Yes")
      b_n += 1
    else:
      print("No")
  else:
    print("No")
# Judge status: Accepted
n = int(input())
nums = [int(i) for i in input().split()]
ans = 0
while True:
    if [i for i in nums if i % 2 == 1]:
        break
    nums = [i//2 for i in nums]
    ans += 1
print(ans)
# Judge status: Accepted
from collections import defaultdict
s = input()

d = defaultdict(int)

for i in s:
  d[i] += 1

if len(s) == 1:
  print ('YES')
  exit()
if len(d) == 1:
  print ('NO')
  exit()
if len(d) == 2:
  if len(s) == 2:
    print ('YES')
    exit()
  else:
    print ('NO')
    exit()


a = list(d.values())
if max(a) - min(a) < 2:
  print ('YES')
else:
  print ('NO')
# Judge status: Accepted
n = int(input())

print((800 * n) - (200 * (n // 15)))
# Judge status: Accepted
N = int(input())
A = sorted(list(map(int, input().split())))
# print([A[-i] for i in range(2, 2*N+1, 2)])
print(sum([A[-i] for i in range(2, 2*N+1, 2)]))
# Judge status: Accepted
N = int(input())

d = {}
for _ in range(N):
    s = input()
    if s not in d:
        d[s] = 0
    d[s] += 1

max_val = max(d.values())
keys = [k for k, v in d.items() if v == max_val]
for k in sorted(keys):
    print(k)
# Judge status: Wrong Answer
from collections import Counter

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

if D[0] != 0:
    print(0)
    exit()

C = sorted(Counter(D).most_common(), key=lambda x: x[0])

if C[0][1] > 1:
    print(0)
    exit()

ans = 1
for i in range(1, len(C)):
    ans *= C[i - 1][1] ** C[i][1]

print(ans)
# Judge status: Accepted
def modinv(a,m):
    return pow(a,m-2,m)

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

P = 10**9+7

nCa = 1

for i in range(1,a+1):
    nCa = nCa*(n+1-i)*modinv(i,P)%P
nCb = nCa
for j in range(a+1,b+1):
    nCb = nCb*(n+1-j)*modinv(j,P)%P

ans = (pow(2,n,P) -1 - nCa - nCb + 2*P)%P
print(ans)
# Judge status: Accepted
A,B,M=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
x=[]
y=[]
c=[]
for _ in range(M):
    x0,y0,c0=map(int,input().split())
    x.append(x0)
    y.append(y0)
    c.append(c0)

ans = min(a) + min(b)

for i in range(M):
    price = a[x[i]-1] + b[y[i]-1] - c[i]
    if price < ans:
        ans = price

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

print(sum(p[:K]))
# Judge status: Accepted
N, R = map(int, input().split())
print(R if N >= 10 else R+100*(10-N))
# Judge status: Accepted
import math


def combination(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))


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

odd = 0
even = 0
for a in A:
    if a % 2 == 0:
        even += 1
    else:
        odd += 1

ans = 0
for i in range(P, odd+1, 2):
    tmp = combination(odd, i)
    for j in range(0, even+1):
        ans += tmp * combination(even, j)
print(ans)
# Judge status: Accepted
from collections import Counter
n = int(input())
A = list(map(int, input().split()))
C = Counter(A)
ans = 0
start, end = min(A), max(A) + 1
for v in range(start, end):
    ans = max(C[v - 1] + C[v] + C[v + 1], ans)
print(ans)
# Judge status: Wrong Answer
#ABC043C
n=int(input())
a = list(map(int, input().split()))
h=sum(a)//len(a)
sum_a=0
for i in range(len(a)):
    sum_a=sum_a+(a[i]-h)**2
print(int(sum_a))
# Judge status: Accepted
if __name__ == "__main__":
    k = int(input())
    a, b = map(int, input().split())
    ans = ""

    if a % k == 0:
        ans = "OK"
    else:
        x = a // k
        if k * (x + 1) <= b:
            ans = "OK"
        else:
            ans = "NG"
    
    print(ans)