peterverebics/CodeNet_Python_118 huggingface dataset:
def f(x):
	return x == x[::-1]
S = input()
l1 = (len(S)-1)//2
l2 = (len(S)+3)//2

S1 = S[:l1]
S2 = S[l2:]
if f(S) and f(S1) and f(S2):
	print("Yes")
else:
	print("No")
#!/usr/bin/ python3.8
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

L = int(read())
print(L**3 / 27)
from decimal import *
L = int(input())

a = Decimal(L/3.0)
print(Decimal(a*a*a))
length = int(input())
ans = length**3 / 27
print(ans)
L=int(input())
print(((10**6)*(L**3)//27)/(10**6))
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [input() for _ in range(n)]

l = int(input())

tmp = l / 3

print(tmp**3)
L = int(input())

ans = (L / 3) ** 3
print(ans)
f = int(input()) / 3.0
print("{:.9f}".format(f * f * f))
L = float(input())
V = L**3 / 27
print(V)
L = int(input())

a = float(L/3)

print(a**3)
l = int(input()) 

print((l/3)*(l/3)*(l/3))
def main():
    L = int(input())
    l = L/3
    print(l*l*l)


main()
if __name__ == '__main__':
    L = int(input())
    side = L / 3
    print(side ** 3)
l = int(input())

a = l/3
b = l/3
c = l/3

print(a*b*c)
L = int(input())


V = L/3 * L/3 * L/3
print(V)
l = int(input())
v = 0

r = l/3
vr = r ** (3)

for i in range(0,l+1):
    for j in range(0,l-i+1):
       if v < i*j*(l-i-j):
           v = i*j*(l-i-j)
    
if vr >= v:
    print(vr)
else:
    print(v)
l = int(input())
x = l / 3
print(x ** 3)
import math
from decimal import Decimal

if __name__ == "__main__":
    L = int(input())
    hoge = L / 3 
    ret = hoge**3
    print(ret)
l = float(input())
print('%.18f' % (l / 3.) ** 3)
l = int(input())
p = l/3
p = p**3
print(p)
L = int(input())

# 普通に立方体が一番大きい
print(pow(L/3,3))
def solve(l):
  return (l/3)**3

l = int(input())
# n, m = [int(s) for s in input().split(" ")]
print(solve(l))
#!/usr/bin/env python3
import sys


def solve(L: int):
    x = L / 3
    print(x**3)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()
if __name__ == "__main__":
    l = int(input())
    l1 = l / 3
    print(l1 ** 3)
n=float(input())    # float
print("%.6f" % pow(n/3, 3))
import numpy

l=int(input())

v=l/3

print(v*v*v)
import sys
input = sys.stdin.readline

l = int(input())
ans = (l / 3) ** 3
print(ans)
L = int(input())

x = (1/3) * L

ans = x**3

print(ans)
L = int(input())

print('{:.10f}'.format((L/3)**3))
L = int(input())
l = L / 3

print(l ** 3)
l=int(input())
print(l/3*l/3*l/3)
l = int(input())

a,b,c = l/3,l/3,l/3

print(a*b*c)
l = int(input(""))
a = 0.001
b = l - 2 * a
V = 0
V_vec = [0,0]
for i in range(l*999):
    if V < a * a * b :
        V = a * a * b
        V_vec = [a,b]
    a += 0.001
    b = l - 2 * a
print(V)
def fl(x):
    digits = 30
    form = '%.'+str(digits-1)+'e'
    return float((form % x))

L=int(input())
print(fl((L*L*L/27)))
L = int(input())

num = L // 3
rem = L % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (L/3)**3
if res > res2:
    print(res)
else:
    print(res2)
L = int( input() )
ret = ( L / 3 ) ** 3
print( ret )
L=int(input())
x=L/3
v=x**3
print(v)
L = int(input())
a = L/3
print(a*a*a)
# -*- coding: utf-8 -*-
 
L = int(input())
 
length = L / 3
 
V = length**3
 
print(V)
import math

L = int(input())
a = L/3
print(pow(a, 3))
import sys
input = sys.stdin.readline

#n = int(input())
#l = list(map(int, input().split()))

'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''
#import copy

#import numpy as np

l=int(input())
if l%3==0:
    print((l//3)**3)
elif l%3==1:
    print((l/3)**3)
else:
    print((l/3)**3)
L=int(input())
#D = L//3
#Amari = L%3
#if Amari == 0:
#    print(D**3)
#elif Amari == 1:
#    print(D*D*(D+1))
#else:
#    print(D*(D+1)*(D+1))
print(L**3/27)
l = float(input())
print("{:.10f}".format((l ** 3) / 27))
x = int(input())
num = x // 3
rem = x % 3
if rem == 1:
    res = (num+1)*(num**2)
elif rem == 2:
    res = ((num + 1) ** 2) * num
else:
    res = num ** 3
res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)
from decimal import Decimal
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    L = input()

    l = Decimal(L) / Decimal('3')
    ans = Decimal(l) ** Decimal('3')
    print(ans)


main()
# input
L = int(input())

print((L / 3) ** 3)
#!/usr/bin/env python3
import sys


def solve(L: int):
    print(L*L*L/27)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()
k=float(input())
volume=(k/3)*(k/3)*(k/3)
print(volume)
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    l=int(input())
    print((l/3)**3)
resolve()
L = int(input())

ans = 0
i = L / 3
ans = i ** 3

print('{:.7f}'.format(ans))
L = int(input())
ans = (L / 3) * (L / 3) * (L / 3)
print(ans)
L=int(input())
h=L/3
print((h**3-2*L*h**2+h*L**2)/4)
import collections


def solve(L):
    oneSideLength = L/3
    return oneSideLength ** 3


L = int(input().strip())
print(solve(L))
l = int(input().strip())

l1 = l / 3

print(l1 ** 3)
import sys
L = int(input())
print((L / 3) ** 3)
def Maximum_Volume(l):

    ans = l / 3

    return ans ** 3

def main():
    l = int(input())
    print(Maximum_Volume(l))
if __name__ == '__main__':
    main()
x = int(input())

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)
def maxvolume( s ): 
  
    # finding length 
    length = (s / 3) 
      
    s -= length 
      
    # finding breadth 
    breadth = s / 2
      
    # finding height 
    height = s - breadth 
      
    return (length * breadth * height) 
l=int(input())
print(maxvolume(l))
def main():
    L = int(input())
    print((L / 3) ** 3)


if __name__ == '__main__':
    main()
L=float(input())

print('{:.08f}'.format((L/3)**3))
l = int(input())
l /= 3
print(l * l * l)
L = int(input())

ans = L**3 / 27

print(ans)
from sys import stdin
input = stdin.readline


def main():
  L = int(input())

  print((L/3)**3)


if(__name__ == '__main__'):
  main()
from decimal import Decimal
L = int(input())
L_ = Decimal(L)/Decimal(3)
print(L_**3)
def main():
    L = int(input())
    ans = (L/3.)**3
    print(ans)

    return

if __name__ == "__main__":
    main()
L = int(input())
x = L/3
ans = x**3
print(ans)
import decimal
L = int(input())
ans = decimal.Decimal(L**3)/decimal.Decimal(27)
print(ans)
#設定
import sys
input = sys.stdin.buffer.readline

#ライブラリインポート
from collections import defaultdict

con = 10 ** 9 + 7
#入力受け取り
def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	L = int(input())
	ans = (L / 3) ** 3
	print(ans)


if __name__ == '__main__':
	main()
from math import *
l=int(input())
k=3*(log10(l)-log10(3))
print(pow(10,k))
l = int(input())
print((l / 3) * (l / 3) * (l / 3))
L=int(input())
di = L/3
print(str(di * di * di))
import decimal
l=input()
l=decimal.Decimal(l)
m=decimal.Decimal(3)
print((l/m)**3)
l=int(input())
l3=l/3
print(l3*l3*l3)
n = int(input())
a=n/3
print(a*a*a)
import math
import numpy as np

L = int(input())
a0 = L/3

print(a0*a0*a0)
from decimal import Decimal
L = Decimal(input())

print((L/3)**3)
l = int(input())

print((l/3)*(l/3)*(l/3))
L = int(input())
y = L / 3

V = (y * ((y - L) ** 2)) / 4
print(V)
# the answer is always a cube. so calculate the volume of that cube.
total_length = float(input())
single_length = total_length/3
volume = single_length**3
print(volume)
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

l = ni()

print(l**3/27)
L = int(input())

volume = (L / 3)**3

print(volume)
n=int(input())
print((n/3)*(n/3)*(n/3))
# coding:utf-8
def main():
    l = int(input())
    ippen = l / 3
    print(ippen*ippen*ippen)


if __name__ == '__main__' :
    main()
a=float(input())
print(a/3*a/3*a/3)
L=int(input())
maxL=L/3
print(maxL*maxL*maxL)
L = int(input())

a = L / 3.0
print(a ** 3)
if __name__ == '__main__':
    a = int(input())
    a = a/3
    print(a*a*a)
L = int(input())
num = L/3
print(num*num*num)
l = int(input())
a = l/3

print(a*a*a)
L = input("")
L = float(L)
S = (L/3)* (L/3)*(L/3)

print(S)
l = float(input())
x=l/3
y=x
z=y
print(z*y*x)
L = int(input())


def main(l):
    x = float(l / 3)

    return x ** 3


print(main(L))
L = int(input())

hen = L/3

print("{:.6f}".format(hen**3))
L = int(input())

dammy = (L/3)**3

print(dammy)
import decimal
L = int(input())

VM1 = decimal.Decimal(L**3)
VM2 = decimal.Decimal(27)

print('{:.10f}'.format(VM1/VM2))
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    L = int(readline())

    ans = pow(L / 3, 3)

    print(ans)
    return


if __name__ == '__main__':
    main()
l = int(input())
ll = l/3
lll = l - 2 * ll
print(ll*ll*lll)
import math
L = int(input())
print((L / 3) ** 3)
# coding: utf-8
# Your code here!
def main():
    l = int(input())
    ans = (l/3) ** 3
    print(ans)
    
main()
def main():
    l = int(input())
    a = l / 3
    print(a**3)


if __name__ == '__main__':
    main()
L = int(input())

x = (L / 3)
y = x
z = x

taiseki = x * y * z
print("{:.08f}".format(taiseki))
a = int(input())

jud = float(a/3) ** 3

print(jud)
l = int(input())

l = float(l / 3)
print(l ** 3)
#!/usr/bin/env python3
import sys

L = int(input())
side = L / 3
print(side**3)
from decimal import *
L = int(input())

print(Decimal(L/3)*Decimal(L/3)*Decimal(L/3))
import sys 
input = sys.stdin.readline
MOD = 10**9 +7
INF = 10**9
from bisect import bisect_right

def main():
    l = int(input())
    ans = (l/3) **3
    print(ans)


if __name__=='__main__':
    main()
L=int(input())
print("{:.6f}".format((L/3)**3))
L = int(input())

a = float(L/3)
b = float(L/3)
c = float(L / 3)

print(a * b * c)
def main():
    l = int(input())
    print((l / 3) ** 3)


if __name__ == "__main__":
    main()
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
L = INT()
print((L/3)**3)
# coding: utf-8

l = int(input())
print((l/3)**3)
import sys
input = lambda: sys.stdin.readline().rstrip()
from decimal import Decimal

L = int(input())  

deceimal_L = Decimal(L)

edge1 = L / 3
edge2 = (L - edge1) / 2
edge3 = L - edge1 - edge2 

print(edge1*edge2*edge3)
#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

def main():
    l = ri()
    print((l*l*l)/27)


if __name__ == '__main__':
    main()
# -*- coding: utf-8 -*-
L = float(input())
S = (L/3)**3
print(S)
l = input()
m = int(l)
N = m/3
v = pow(N,3)
print(v)
l = int(input())

ans = (l / 3) ** 3

print(ans)
L = int(input())
ans = (L*L*L)/27
print(ans)
import sys
input=sys.stdin.readline
l=int(input())
x=l/3
print(x**3)
S = float(int(input()))/float(3)
print(S*S*S)
#!/usr/bin/python3
# -*- coding:utf-8 -*-

def main():
  l = int(input())
  print((l/3)**3)

if __name__=='__main__':
  main()
L = int(input())
a=b=c=L/3
print(a*b*c)
import math

l = int(input())

print(math.pow(l/3, 3))
L = float(input())
side = L / 3.0
res = side ** 3
print(res)
from decimal import *

n = int(input())
result = Decimal(n / 3)
print(Decimal(result ** 3))
class atcorder:
    
    L=int(input())
    
    a=L/3
    
    print(a*a*a)
def main():
    L = int(input())

    return (L / 3) ** 3

print(main())
L=int(input())
A=L/3
B=L-(2*A)
ans=A*B*B
print(ans)
l = int(input())
ans = (l / 3) ** 3
print(ans)
l = int(input())
num=(l/3)
print(num*num*num)
# -*- coding: utf-8 -*-
print((int(input()) / 3) ** 3)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

l = int(input())
print((l/3) ** 3)
s = int(input())
l = s / 3
s -= l 
b = s / 2
h = s - b 
    
print(l * b * h)
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    L=I()
    print((L/3)**3)

main()
#!/usr/bin/env python3
import sys


def solve(L: int):
    a,b,c=L/3,L/3,L/3
    print(a*b*c)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()
# coding: utf-8
# Your code here!
n=int (input())

s = n/3.0
ans = s**3

print('{:.12f}'.format(ans))
n=int(input())
n=n/3
x=n**3
print ("{0:.6f}".format(x))
from decimal import Decimal
L = int(input())

print(Decimal((L/3)**3))
L = input()
a=int(L)/3
print((a*(a-int(L))**2)/4)
import math
L = int(input())
print(math.pow(L/3,3))
def resolve():
    L = float(input())
    print((L**3)/27)

if __name__ == '__main__':
    resolve()
import decimal
decimal.getcontext().prec = 12
L = int(input())
l = decimal.Decimal(L/3)
print(l**3)
L = int(input())
d = L / 3
print(d ** 3)
from decimal import Decimal
l = Decimal(input())
d = l / Decimal(3)
print(d**Decimal(3))
"""
"""


def int_as_array(num): return list(map(int, [y for y in str(num)]))


def array_as_int(arr): return int(''.join(map(str, arr)))


def read_int(): return int(input())


def read_array(): return list(map(int, input().split(' ')))


def array_to_string(arr, sep=' '): return sep.join(map(str, arr))


def matrix_to_string(arr, sep=' '): return '[\n' + '\n'.join(
    [sep.join(map(str, row)) for row in arr]) + '\n]'


def solve(L):
    return (L / 3) ** 3


L = read_int()
print(solve(L))
def main():
    l = int(input())
    print((l / 3) ** 3)


if __name__ == '__main__':
    main()
from decimal import Decimal, getcontext
getcontext().prec = 50
S = int(input())
print(Decimal(pow(Decimal(Decimal(S)/Decimal(3)), Decimal(3))))
#!/usr/bin/python3
import sys
input = lambda: sys.stdin.readline().strip()
L = int(input())
print(f'{(L / 3) ** 3:.6f}')
from decimal import Decimal as dec
L = int(input())
dL = dec(L)

print((dL/3)**dec(3))
L = input()
dist = float(L) / 3

print(dist*dist*dist)
L = int(input())
print((L / 3.0) ** 3.0)
x = int(input())
y = float(x/3)
print(y**3)
def main():
    L = int(input())

    i = L/3

    print(i*i*i)

main()
# -*- coding: utf-8 -*-

L = int(input())

print(L**3 / 27)
from decimal import *

N = int(input())

def solve(N):
    hoge = float(N) / 3
    hoge = str(hoge)
    return Decimal(hoge)*Decimal(hoge)*Decimal(hoge)

print(solve(N))
def solve():
    print((int(input()) / 3) ** 3)
solve()
import fractions
L = int(input())
a = fractions.Fraction(L, 3)
ans = float(a ** 3)
print(ans)
l = int(input())

hen = l / 3

ans = hen * hen * hen

print(ans)
L=int(input())
l=L/3
print(l*l*l)
import decimal
    
num = decimal.Decimal(input())
calc_num = decimal.Decimal(num / 3)
print(calc_num * calc_num * calc_num)
L = int(input())

l1 = L / 3.0
print(l1**3)
L = int(input())

print((L/3)*(L/3)*(L/3))
S=int(input())
l=S/3

print(l*l*l)
import decimal
decimal.getcontext().prec = 20
S = decimal.Decimal(input()) 
s = S/3
print(decimal.Decimal(s**3))
L = int(input())
x = L / 3.0
z = L - 2.0 * x
print(x * x * z)
L = int(input())
x = L/3
print(x*x*x)
# coding:utf-8

L = int(input())
print((L/3)**3)
l = int(input())


ans = 0.0

ans += l/3*l/3*l/3

print("{:.10f}".format(ans))
L = int(input())

l = L/3
print(l*l*l)
l = int(input())
s = l/3
ans = s**3
print(ans)
import sys

l = int(sys.stdin.readline())

print((l**3)/27)
L = int(input())
print(L/3 * L/3 * L/3)
import sys


def main():
    input = sys.stdin.buffer.readline
    l = int(input())
    print((l / 3) ** 3)


if __name__ == "__main__":
    main()
import itertools
import functools
import math
from collections import Counter
from itertools import combinations


L = int(input())

ans=(L/3)**3

print(ans)
# coding: utf-8
init = int(input())
print(pow(init/3,3))
import sys
input = sys.stdin.readline

L = int(input())

l = L / 3
print(L ** 3 / 27)
L = int(input())
a = L/3
b = a**3
print(b)
l = int(input())
x = l/3
v = x*x*x
print(v)
def main():
    L = int(input())
    ans = '{:.010f}'.format(L*L*L/27)
    print(ans)

main()
def sol():
    x = int(input())
    ans = (x / 3) ** 3
    print(ans)


if __name__ == '__main__':
    sol()
# -*- coding: utf-8 -*-

def main():
     l = int(input())
     ans = (l / 3) ** 3
     print(ans)

if __name__ == "__main__":
    main()
L=int(input())
import math
l=L/3
print(l**3)
L = int(input())

print(L/3 * L/3 * L/3)
l = int(input())

ans = l ** 3 / 27

print(ans)
s = int(input())

out = s/3 * s/3 * s/3 
print(out)
l = int(input())
a = l/3
b = l/3
c = l - a - b
cub = a * b * c
print(cub)
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

def solve():
    l = II()

    print(1 / 27 * l ** 3)


if __name__ == '__main__':
    solve()
# 2020/03/22
# AtCoder Beginner Contest 159 - C

# Input
l = int(input())

# Calc
wkl = l / 3
ans = wkl ** 3

# Output
print(ans)
from sys import stdin

def main():

    input = stdin.readline

    L = int(input())

    ans = (L / 3) ** 3

    print(ans)

    
if __name__ == "__main__":
    main()
L=int(input())
l=L/3
ans=l*l*l
print("{:.07f}".format(ans))
L = int(input())
print((L/3) * (L/3) * (L/3))
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    L = ir()
    print((L/3)**3)
resolve()
L = int(input())
A = L / 3
print(A * A * A)
from decimal import Decimal

L = int(input())

w = Decimal(L / 3)
d = Decimal(L / 3)
h = Decimal(L / 3)

ans = Decimal(w * d * h)

print(ans)
L = int(input())
l1 = L / 3
l2 = (L - l1) / 2
l3 = L - l1 - l2

print(l1 * l2 * l3)
L = int(input())
m = L*1000000//3
volume = m/1000000*m/1000000*(L*1000000-2*m)/1000000
print(volume)
l = int(input())

n = l / 3

print(n * n * n)
L = int(input())
l = L / 3
print(l ** 3)
L = int(input())

L_3 = L / 3

print(L_3**3)
from decimal import *

L = int(input())

if L%3 ==0:
    L1 = L/3
    print(L1**3)
else:
    print(Decimal(L/3)**3)
L = int(input())
l=float(L/3)
print(l*l*l)
l = int(input())
print((l/3)*(l/3)*(l/3))
L = int(input())
a = L / 3
ans = a**3
print("{:.10f}".format(ans))
l = int(input())
x = l/3
print(x*x*x)
l = int(input())

e = l / 3

res = e * e * e

print(res)
n=int(input())
ans=(n/3)**3
print("{0:.6f}".format(ans))
#!/usr/bin/env python3
N = int(input().strip())
print((N / 3) ** 3)
L = int(input())
a=float(L/3)
V=a**3
print(V)
L = float(input())

returnVal = (L/3)**3
print(returnVal)
#!python3.4
# -*- coding: utf-8 -*-
# abc159/abc159_c
import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    L = i2n()
    print(L * L * L / 27)
    return

main()
def c_maximum_volume():
    L = int(input())
    return round((L / 3)**3, 10)

print(c_maximum_volume())
L = int(input())

ans = 0
for i in range(1, 1001):
  for j in range(1, 1001):
    if i + j > 1000 or i + j > L:
      break
    for k in range(1, 1001):
      if i + j + k > 1000 or i + j + k > L:
        break
      ans = max(ans, i * j * k)
print(ans)
L = int(input())

temp = 0
for i in range(1,L):
    for j in range(1,L-i):
        mult = i*j*(L-i-j)
        if(temp < mult):
            temp = mult
print(float(temp))
import math
L = int(input())

length = L*100
max_vol=0
for w in range(1,math.ceil((length+1)/3)):
    if max_vol<w*((length-w)/2)**2:
        max_vol = w*((length-w)/2)**2
print(max_vol/1000000)
l = int(input())

res = 0
for i in range(1, l):
    for j in range(i, l):
        if l > i+j:
            k = l - (i+j)
            res = max(res, k*i*j)
print(res)
l=int(input())

ans=0
for i in range(l):
  for j in range(l-i):
    ans=max(ans,i*j*(l-i-j))
print(ans)
L = int(input())

ans = 0
for i in range(1, L-1):
  for j in range(1, L - i):
    if L - i - j > 0:
      ans = max(ans, i * j * (L - i - j))
      
print(ans)
L = int(input())
a = L // 3
b = a
c = L - a - b
print(a*b*c)
l = int(input())*10
Ma = 0

for i in range(1, l+1, 1):
    for j in range(1, l-i+1, 1):
        z = l - (i+j)
        result = z*i*j
        if(result>Ma):
            Ma = result
print(Ma/1000)
import sys


def resolve(in_):
    L = int(in_.read())
    return L ** -3


def main():
    answer = resolve(sys.stdin)
    print(answer)


if __name__ == '__main__':
    main()
l=int(input())
ans=0
for i in range(0,l+1):
    for j in range(0,l+1):
        e=l-i-j
        ans=max(i*j*e,ans)
print(ans)
l=int(input())
res=0
for i in range(1,l-1):
    for j in range(1,l-1):
        s=l-i-j
        if res<i*j*s:
            res=i*j*s
print(res)
def resolve():
    L = int(input())
    ans = float(0)
    for x in range(1, L):
        for y in range(1, L-x):
            x = float(x)
            y = float(y)
            z = float(L) - x - y
            ans = max(ans, x*y*z)

    print(ans)
if __name__ == '__main__':
    resolve()
import math

L = int(input())

ans = 0
for x in range(math.floor(L/3)-1, math.ceil(L/3)+1):
    for y in range(math.floor(L/3)-1, math.ceil(L/3)+1):
        for z in range(math.floor(L/3)-1, math.ceil(L/3)+1):
            if x+y+z == L:
                tmp = x*y*z
                ans = max(ans, tmp)
print(float(ans))
import math
from decimal import Decimal

if __name__ == "__main__":
    L = int(input())
    hoge = L / 3 
    ret = (hoge* 10**6) **3
    print(ret)
import sys
L=int(input())

length=int(L/3)
L=L-length
width=int(L/2)
L=L-width
height=L
print(length*width*height)
n = int(input())

if n % 3 == 0:
    print((n//3)**3)
else:
    a = n//3
    b = n//3
    c = n - a - b
    print(a * b * c)
l = int(input())
if l%3 == 0:
    print((l/3)**3)
elif l%3 == 1:
    print((l/3)*(l/3)*(l/3 + 1))
else:
    print(((l/3)*(l/3 + 1)*(l/3 + 1)))
# -*- coding: utf-8 -*-

L = int(input())

maxV = 0

for x in range(1,L+1):
    for y in range(1,L+1):
        z = L-(x+y)

        V = x*y*z
    
        if maxV < V:
            maxV = V


print(maxV)