Problem:
 Score : 300 points    Problem Statement Given is a positive integer L .
Find the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L .      Constraints  1 ≤ L ≤ 1000  L is an integer.         Input Input is given from Standard Input in the following format:  L       Output Print the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L .
Your output is considered correct if its absolute or relative error from our answer is at most 10^{-6} .        Sample Input 1 3      Sample Output 1 1.000000000000  For example, a rectangular cuboid whose dimensions are 0.8 , 1 , and 1.2 has a volume of 0.96 .  On the other hand, if the dimensions are 1 , 1 , and 1 , the volume of the rectangular cuboid is 1 , which is greater.       Sample Input 2 999      Sample Output 2 36926037.000000000000

Solution (Python):
L=int(input())
ans=(L/3)**3
print(ans)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
a = int(input())
print((a / 3) ** 3)

Solution (Python):
L = int(input())
x = L/3
ans = x**3
print(ans)

Solution (Python):
L = int(input())

print(L**3/27)

Solution (Python):
l=int(input())
print((l*l*l)/27)

Solution (Python):
L=int(input())

print((L**3)/27)

Solution (Python):
L = int(input())

print((L/3)*(L/3)*(L/3))

Solution (Python):
L = int(input())

print((L/3)**3)

Solution (Python):
L= int(input())

a = L/3
V = a**3

print(V)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):

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

Solution (Python):

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

Solution (Python):
l = int(input())
       
print((l/3) ** 3)

Solution (Python):


nagasa = int(input())

print((nagasa / 3) ** 3)

Solution (Python):
L = int(input()) 




x = L/3
y = L/3
h = L/3

N = int((((L/6)/0.1)))

Max = 0

for i in range(-N,N+1):
  x = L /3 + 0.1 * i
  y = L/ 3 - 0.1 * i
  h = L/ 3
  L3 = x * y *h
  if L3 > Max:
    Max = L3
print(Max)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L=int(input())
l=L/3
print(l**3)

Solution (Python):
L = float(input())
M = L/3
print(M*M*M)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
l=int(input())
x=l/3
print (pow(x,3))

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
n = int(input())
print((n / 3) ** 3)

Solution (Python):
from decimal import Decimal

L = Decimal(input())
v = Decimal(L / 3)
w = Decimal(v)
h = Decimal(w)

print(Decimal(v * w * h))

Solution (Python):
L = input()

L1 = round((float(L)/3),6)
L2 = round(float(L) - L1 * 2,6)



print(round(L1**2*L2,6))

Solution (Python):
L=int(input())
ans=(L/3)**3
print(ans)

Solution (Python):
L = int(input())

print((L / 3) ** 3)

Solution (Python):
L = int(input())
ans = (L / 3) * (L / 3) * (L / 3)
print(ans)

Solution (Python):
def Maximum_Volume(l):

    ans = l / 3

    return ans ** 3

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

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):


import sys


def IOE():
    sys.stdin = open("input.txt", "r")
    sys.stdout = open("output.txt", "w")


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


if __name__ == "__main__":
    
    main()

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
l3=int(input())
l=l3/3
print(l**3)

Solution (Python):
print('{:.10g}'.format((int(input())/3) ** 3))

Solution (Python):
l=int(input())
print(l**3/27)

Solution (Python):
n=int(input())
n=n/3
print(n*n*n)

Solution (Python):
l = int(input())

print((l*(1/3))**3)

Solution (Python):
N = int(input())

n = N / 3

print(n**3)

Solution (Python):
n = int(input())
print((n/3)*(n/3)*(n/3))

Solution (Python):
n = int(input())
print(n/3*n/3*n/3)

Solution (Python):
L = int(input())

print((L / 3)**3)

Solution (Python):
length_sum=float(input())
print((length_sum/3)**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):

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

Solution (Python):
L=int(input())
print(L**3/27)

Solution (Python):
l = int(input())

print(l*l*l/27)

Solution (Python):
L = int(input())
a = L / 3
print(a * a * a)

Solution (Python):
n = int(input())
l = n/3
ans = pow(l,3)
print(ans)

Solution (Python):
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)

Solution (Python):
L = int(input())

l = L ** 3 / 27

print(l)

Solution (Python):
L = int(input())

f = L / 3
print(f * f * f)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
L = int(input())

print((L / 3) ** 3)

Solution (Python):
l = int(input())
if l%3 == 0:
    print((l//3)**3)
else:
    t = l//3
    if l%3 == 1:
        print(t**3+t**2+t/3+1/27)
    else:
        print(t**3+2*t**2+4*t/3+8/27)

Solution (Python):
l = int(input())
print(l ** 3 / 27)

Solution (Python):
L = int(input())
print((L / 3) ** 3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
L = int(input())
print(L ** 3 / 27)

Solution (Python):
L = int(input())
print(L ** 3 / 27)

Solution (Python):
L = int(input())
print(L ** 3 / 27)

Solution (Python):
print(pow(float(input())/3,3))

Solution (Python):
from fractions import gcd
import sys
sys.setrecursionlimit(4100000)

def ols(): return input()
def oli(): return map(int, input().split())
def olai(): return list(map(int, input().split()))
def olas(): return list(input().split())
def mlai(L): return [int(input()) for _ in range(L)]
def mlas(L): return [input() for _ in range(L)]

def ar(a, b, c=-1, d=-1, INIT=0):
    if(c==-1): return [[INIT]*b for _ in range(a)]
    if(d==-1): return [[[INIT]*c for _ in range(b)] for __ in range(a)]
    return [[[[INIT]*d for _ in range(c)] for __ in range(b)] for ___ in range(a)]

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

"""
P = 10**9 + 7
N = 700000 
inv = [0] + [1] 
finv = [1] + [1] 
fac = [1] + [1] 
for i in range(2, N):
  inv += [inv[P % i] * (P - int(P / i)) % P]
  fac += [(fac[i-1] * i) % P]
  finv += [(finv[i-1] * inv[i]) % P]

def comb(a, b):
    if a<b: return 0 
    return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
"""

l, = oli()
print((l/3)**3)

Solution (Python):
from fractions import gcd
import sys
sys.setrecursionlimit(4100000)

def ols(): return input()
def oli(): return map(int, input().split())
def olai(): return list(map(int, input().split()))
def olas(): return list(input().split())
def mlai(L): return [int(input()) for _ in range(L)]
def mlas(L): return [input() for _ in range(L)]

def ar(a, b, c=-1, d=-1, INIT=0):
    if(c==-1): return [[INIT]*b for _ in range(a)]
    if(d==-1): return [[[INIT]*c for _ in range(b)] for __ in range(a)]
    return [[[[INIT]*d for _ in range(c)] for __ in range(b)] for ___ in range(a)]

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

"""
P = 10**9 + 7
N = 700000 
inv = [0] + [1] 
finv = [1] + [1] 
fac = [1] + [1] 
for i in range(2, N):
  inv += [inv[P % i] * (P - int(P / i)) % P]
  fac += [(fac[i-1] * i) % P]
  finv += [(finv[i-1] * inv[i]) % P]

def comb(a, b):
    if a<b: return 0 
    return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
"""

l, = oli()
print((l/3)**3)

Solution (Python):
L = int(input())
print(L/3 * L/3 * L/3)

Solution (Python):
import scipy.optimize

L = int(input())

func = lambda x: -1 * (x[0] * x[1] * (L - x[0] - x[1]))

res = scipy.optimize.minimize(func, (0.1 ,0.2), bounds = ((0, None), (0, None)), tol=1e-6)

print(-1 * res.fun)

Solution (Python):
l = int(input())

ans = (l/3)**3

print(ans)

Solution (Python):
L = int(input())
hen = L/3
print('{:.12f}'.format(hen*hen*hen))

Solution (Python):
l = int(input())
print(1/(3**3)*l**3)

Solution (Python):
L=int(input())

print(L*L*L/27)

Solution (Python):
L = int(input())
print(L*L*L/27)

Solution (Python):
from math import pow
n=int(input())
n/=3
print(pow(n,3))

Solution (Python):
length = int(input())
print((length / 3)**3)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
L = int(input())
print(L ** 3 / 27)

Solution (Python):
L = int(input())

print("{:.12f}".format((L / 3)**3))

Solution (Python):
L = int(input())
a = L / 3
print(a * a * a)

Solution (Python):
import math
L = int(input())
a = L / 3
print(a**3)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
n=int(input())
print(n**3/27)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    l = I()
    r = l/3
    print(r*r*r)
    return



if __name__ == "__main__":
    solve()

Solution (Python):


from sys import stdin, stdout

l = int(input())

value = l/3
answer = value*value*value
print (answer)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
L = int(input())
print((L / 3) ** 3)

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):

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

Solution (Python):
n = int(input())
print((n / 3)**3)

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
user_input = float(input())
devided_input = user_input / 3.0
print(devided_input**3)

Solution (Python):
s=int(input())
print((s/3)**3)

Solution (Python):
L = int(input())

print(L**3 / 27)

Solution (Python):
n=int(input())
l=n/3
print(l*l*l)

Solution (Python):
x = int(input())
y = float(x/3)
print(y**3)

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):
L = int(input())

a = L / 3
print(a*a*a)

Solution (Python):
L = int(input())
print(L ** 3 / 3 ** 3)

Solution (Python):


l = int(input())

print((l/3)**3)

Solution (Python):
L = int(input())
ans = (L / 3) ** 3
print(ans)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
l = input()
l = float(l)
hen = l / 3
volume = hen**3
print(volume)

Solution (Python):
def main():
    L = int(input())
    l = L**3
    res = l/27
    print(res)

if __name__ == "__main__":
    main()

Solution (Python):
L = int(input())

print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
n = float(input())
print((n / 3) * (n / 3) * (n / 3))

Solution (Python):
L = int(input())
a = b = c = L/3
A = a*b*c
print(A)

Solution (Python):
L = int(input())

print(pow(L, 3)/27)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
import decimal
decimal.getcontext().prec = 12
L = int(input())
l = decimal.Decimal(L/3)
print(l**3)

Solution (Python):
L = int(input())
print((L * L * L) / 27)

Solution (Python):
from sys import stdin
r = stdin.readline

def main():
    L = int(r())
    print("%.12f"%(L/3)**3)

main()

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
print(int(input())**3/27)

Solution (Python):
l = int(input())

hen = l / 3

ans = hen * hen * hen

print(ans)

Solution (Python):
n = int(input())
print((n/3)**3)

Solution (Python):

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

Solution (Python):
import math

print(math.pow(int(input())/3,3))

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
number = int(input())
sideLength = number/3 * 100
print('{:f}'.format((sideLength**3)/(10**6)))

Solution (Python):
def solve(l):
    return (l / 3) ** 3

l = int(input())
print(solve(l))

Solution (Python):
L = int(input())
print((L / 3) ** 3)

Solution (Python):
a = float(input())
print(pow(a/3, 3))

Solution (Python):
L = int(input())

answer = L ** 3 / 27
print(answer)

Solution (Python):
l = int(input())

from decimal import *
n = Decimal(l/3).quantize(Decimal('.001'))

print((l-2*n)*n*n)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
print(int(input())**3 / 27)

Solution (Python):
l = int(input())
mxv = float((l/3) ** 3)
print(mxv)

Solution (Python):
L = int(input())
print(L*L*L/27)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
l = int(input())
a = l/3
print(a**3)

Solution (Python):
L = int(input())

result = (L/3)**3

print(result)

Solution (Python):
l = float(input())
x = ("{:.7f}".format((l / 3)**3))
print(x)

Solution (Python):
L = float(input())

print('{:.10f}'.format((L / 3)**3))

Solution (Python):
n = int(input())

print((n/3)**3)

Solution (Python):
print((int(input()) / 3) ** 3)

Solution (Python):
L = int(input())
l=float(L/3)
print(l*l*l)

Solution (Python):
sum_ = float(input())
taiseki = float((sum_/3)**3)
print('%.7f'%taiseki)

Solution (Python):
L = float(input())
print(L ** 3 / 27)

Solution (Python):
L = int(input())
a = L/3
print(pow(a, 3))

Solution (Python):
L = int(input())
K = (L/3)**3
print(K)

Solution (Python):
import numpy as np
from scipy.optimize import minimize

L = int(input())

def objective(X):
    x = X[0]
    y = X[1]
    z = X[2]
    return - x * y * z

def constraint(X):
    x = X[0]
    y = X[1]
    z = X[2]
    return x + y + z - L


X0 = [0.1 * L, 0.2 * L, 0.7 * L]


b = (0.0, L)
bnds = (b, b, b)
cons = [{'type': 'eq', 'fun': constraint}]

sol = minimize(objective, X0, method='SLSQP', bounds=bnds, constraints=cons)
print(-sol.fun)

Solution (Python):
N = int(input())
print(N**3 / 27)

Solution (Python):
a=int(input())
print((a/3)**3)

Solution (Python):





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

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
print((float(input()) / 3.0)**3)

Solution (Python):
L = int(input())

ans = (L ** 3) / 27
print(ans)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

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

if __name__ == '__main__':
    main()

Solution (Python):
l = int(input())

print((l / 3) ** 3)

Solution (Python):
s=int(input())

print((s/3)**3)

Solution (Python):
l = int(input())

print((l/3)**3)

Solution (Python):
def main():
    L = int(input())
    ans = (L / 3) ** 3
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
L = int(input())

print((L/3)**3)

Solution (Python):
if __name__ == '__main__':
    a = int(input())
    
    print((a/3)*(a/3)*(a/3))

Solution (Python):
n = float(input())
print((n/3.0)**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
X = input()
X2 = float(X)/3
Y = X2 * X2 * X2

print(Y)

Solution (Python):
L = input()
a=int(L)/3
print((a*(a-int(L))**2)/4)

Solution (Python):


L = int(input())

print((L/3)**3)

Solution (Python):
n = int(input())
print(n*n*n/27)

Solution (Python):
L=int(input())
A=(L/3)*(L/3)*(L/3)
print(A)

Solution (Python):
n = int(input())

print((n/3)**3)

Solution (Python):
print((int(input()))**3*(1/27))

Solution (Python):

def inputlist(): return [int(i) for i in input().split()]


L = int(input())
k = L/3
ans = k**3
if ans.is_integer():
    ans = str(ans)+'00000000000'
print(ans)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L = int(input())
num = L / 3
print(num**3)

Solution (Python):
l = float(input())
print((l/3)**3)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
l = int(input())
print(l**3/27)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
l = int(input())
ans = (l / 3) ** 3
print(ans)

Solution (Python):
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

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

Solution (Python):
L = int(input())
print((L / 3) ** 3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
print(((int(input())/3)**3))

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
s = float(input())
print((s / 3) ** 3)

Solution (Python):
L = int(input())
L1 = L/3
ans = L1**3
print(ans)

Solution (Python):
L = int(input())

l = L / 3.


print(l**3)

Solution (Python):
num = int(input())
tmp = num / 3
print(tmp * tmp * tmp)

Solution (Python):
a=int(input())
print((a/3)**3)

Solution (Python):
l = float(input())
print((l/3)**3)

Solution (Python):
l = int(input())
print((l/3) ** 3)

Solution (Python):
l = int(input())
print((l/3) ** 3)

Solution (Python):
a=int(input())
s=a/3
print(s**3)

Solution (Python):
L = int(input())
V = L**3 / 27
print(V)

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):
l = int(input())
print(l/3 * l/3 * l/3)

Solution (Python):
n=int(input())
a=n / 3
if(a*3 ==n):
    print(a*a*a)

Solution (Python):
GI = lambda: int(input()); GIS = lambda: map(int, input().split()); LGIS = lambda: list(GIS())

def main():
    l = GI()
    print((l / 3) ** 3)

main()

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):




import sys
from io import StringIO
import unittest

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

def resolve():
    readline=sys.stdin.readline

    
    

    L=int(readline())


    print((L/3)**3)


    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
x = int(input())
print((x/3)**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
L = float(input())
print((L/3)**3)

Solution (Python):
L = int(input())
print((L/3 )** 3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
n=int(input())
print((n/3)**3)

Solution (Python):
l=int(input())
x=l/3
print(x*x*x)

Solution (Python):


from decimal import Decimal


L = input()

LD = Decimal(L)
LD = LD/3

ans = LD ** 3

print(ans)

Solution (Python):
l=float(input())

x=l/3
print((l/3)**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
print((int(input()) / 3.0) ** 3)

Solution (Python):
L = int(input())
a = L/3
print(a**3)

Solution (Python):
from collections import *
from heapq import *
from itertools import *
from fractions import gcd
import sys
from decimal import *
import copy
input=lambda :sys.stdin.readline().rstrip()

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

Solution (Python):
l = int(input())

n =float(l/3)

print(n*n*n)

Solution (Python):
L = int(input())
print((float(L)/3)**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
l = int(input())

area = float(l/3)
print(area**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
L = int(input())

print((L/3)**3)

Solution (Python):


N = int(input())









ans = N*N*N/27.0
print('{0:.12f}'.format(ans))

Solution (Python):
n = int(input())
a = n/3
print("{0:.10f}".format(a*a*a))

Solution (Python):
L = int(input())

a = L / 3

print(a ** 3)

Solution (Python):
print(int(input())**3/27.0)

Solution (Python):
L = int(input())
print((L**3)/27)

Solution (Python):
print(int(input()) ** 3 / 27)

Solution (Python):
Lf = float(input(''))
ans = (Lf/3*(Lf/3)*(Lf/3))
print('%.6f'%ans)

Solution (Python):
import math
L = int(input())
print(math.pow(L/3,3))

Solution (Python):
L = int(input())

print(float(L*L*L/27))

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):
は=int(input())
print((は/3)**3)

Solution (Python):
L = int(input())
l = L/3
print(l**3)

Solution (Python):
l = int(input())
print(l*l*l/27)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):
l=int(input())
print(l**3/27)

Solution (Python):
L = int(input())
print((L/3)**(3))

Solution (Python):
l = int(input())
L = l/3
print(L*L*L)

Solution (Python):
l = int(input())

print((l / 3) ** 3)

Solution (Python):
l = int(input())

print(pow(l/3, 3))

Solution (Python):
L = int(input())

result = L / 3  
result = result * result * result
  
print(result)

Solution (Python):
L = int(input())
print(pow(L/3,3))

Solution (Python):
L = int(input())

print(pow((L/3), 3))

Solution (Python):
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()

Solution (Python):
L = float(input())
print((L/3)**3)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
no=int(input())
print(pow((no/3),3))

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):
l = float(input())
print((l/3)**3)

Solution (Python):
a = int(input())
print((a/3)**3)

Solution (Python):
l = int(input())
e = l / 3
print(e*e*e)

Solution (Python):
from decimal import Decimal
L=int(input())
print(Decimal(L/3)**3)

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):

L = int(input())




half = L/3
print(half**3)

Solution (Python):
l = int(input())

v = (l / 3) ** 3
print(v)

Solution (Python):
l = int(input())
volume = (l/3)**3
print(volume)

Solution (Python):
a=float(input()) / 3
print(a*a*a)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l / 3) ** 3)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
S = int(input())
ans = (S**3)/27
print(ans)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
L = int(input())

print((L**3)/27)

Solution (Python):
L = int(input())

print((L/3)**3)

Solution (Python):
n=int(input())
n=n/3
x=n**3
print ("{0:.6f}".format(x))

Solution (Python):
n=int(input())
n=n/3
x=n**3
print ("{0:.6f}".format(x))

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
print((int(input()) / 3)**3)

Solution (Python):
L = int(input())

div = L/3
print(div*div*div)

Solution (Python):
L = int(input())

ans = round((L/3)**3,6)
print(ans)

Solution (Python):
import sys
import os
import collections


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    L = int(sys.stdin.buffer.readline().decode().rstrip())
    print(L ** 3 / 27)


if __name__ == '__main__':
    main()

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
L = float(input())
print(pow(L/3, 3))

Solution (Python):
L = int(input())

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

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
L=int(input())
out=(L/3)**3
print(out)

Solution (Python):
l = float(input())

print((l/3)**3)

Solution (Python):
L = int(input())
ans = (L/3)**3
print(ans)

Solution (Python):
n=int(input())
n=n/3
print(n*n*n)

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Solution (Python):
L=int(input())
ip=L/3
print(ip*ip*ip)

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):
L = int(input())

print('{:.10f}'.format((L/3)**3))

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
n = int(input())
print((n/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
import sys,bisect,string,math,time,functools,random
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[];g=[[] for i in range(n)]
    for i in range(E):
        inp=LI();org_inp.append(inp)
        if index==0:inp[0]-=1;inp[1]-=1
        if len(inp)==2:
            a,b=inp;g[a].append(b)
            if not Directed:g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
            if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,boundary=1,search=[],replacement_of_found='.',mp_def={'

    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):return [[tb//(n**bt)%n for bt in range(k)] for tb in range(n**k)]
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)
def show2d(g,h,w):
    for i in range(h):show(g[i*w:i*w+w])

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

input=lambda: sys.stdin.readline().rstrip()

def ran_input():
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True

l=I()
print((l/3)**3)

Solution (Python):
L = int(input())
hen = L/3
print('{:.12f}'.format(hen*hen*hen))

Solution (Python):
l = int(input())
a = l/3
print(a**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
n=int(input())
print((n/3)**3)

Solution (Python):
N = int(input())
x = N/3.0
print(x**3)

Solution (Python):
n = int(input())
a = n /3
b = n -a 
b = b /2
print( a * b * b)

Solution (Python):
from sys import exit, stdin
N = int(stdin.readline().rstrip())
print(N/3*N/3*N/3)

Solution (Python):
l = int(input())

print(l**3/(3**3))

Solution (Python):
N = int(input())
print((N/3)**3)

Solution (Python):
n=float(input())    
print("%.6f" % pow(n/3, 3))

Solution (Python):
L = int(input())
print((L / 3) ** 3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
l = int(input())

result = (l/3)**3
print(result)

Solution (Python):


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

Solution (Python):




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

Solution (Python):
n = float(input())

print(n**3/27)

Solution (Python):
l = int(input())

a = l/3
b = l/3
c = l/3
print(a*b*c)

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    L = int(input())
    print(pow(L/3, 3))


if __name__ == "__main__":
    main()

Solution (Python):
L = int(input())
print(L**3/27)

Solution (Python):
L = int(input())/3
print(L*L*L)

Solution (Python):
L = int(input())

l = float(L/3)

print('{:.12f}'.format(l*l*l))

Solution (Python):
import numpy as np

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

Solution (Python):
l = int(input())
print(l/3*l/3*l/3)

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l=int(input())
i=l/3
print(i**3)

Solution (Python):
a=float(input())
a=a/3 
print(a**3)

Solution (Python):
i = int(input())
i /= 3
print(i*i*i)

Solution (Python):
l=int(input())
n=l/3
print(n**3)

Solution (Python):
def main():
    l = int(input())

    print((l/3)**3)

if __name__ == '__main__':
    main()

Solution (Python):
L=int(input())
print((L/3)**3)

Solution (Python):
l = int(input())

print((l/3)**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
l=int(input())
print((l/3)*(l/3)*(l/3))

Solution (Python):
l = int(input())
t = l / 3
ans = t ** 3
print(ans)

Solution (Python):
n = float(input())
ans = (n/3)**3
print("{:.10f}".format(ans))

Solution (Python):
import scipy.optimize as optimize


def main():
    L = float(input())
    def fun(x): return -x[0] * x[1] * x[2]
    cons = ({'type': 'eq', 'fun': lambda x: x[0] + x[1] + x[2] - L})
    bnds = ((0, None), (0, None), (0, None))
    res = optimize.minimize(fun, (0, 0, 0), method='SLSQP',
                            bounds=bnds, constraints=cons, tol=1e-8)
    print("{:.18f}".format(-res.fun))


main()

Solution (Python):
L = int(input())
one = L / 3
print(one ** 3)

Solution (Python):
l = int(input())

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

print(a*b*c)

Solution (Python):
L = int(input())

print((L / 3)  ** 3)

Solution (Python):
l = float(input())
print((l/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
print(int(input()) ** 3 / 27)

Solution (Python):
val = input()
val = float(val)
a = val / 3
print(a * a * a)

Solution (Python):
def main(l):
    return l**3 / 27

l = int(input())
print(main(l))

Solution (Python):
def main():
    L = int(input())
    ans = (L / 3) ** 3
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
l = int(input())
print((l / 3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L=int(input())

v=L/3

print(v*v*v)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
l = int(input())
print(l**3/27)

Solution (Python):
import sys
def II(): return int(sys.stdin.readline())
L = II()
print((L/3)**3)

Solution (Python):
L=int(input())
print((L**3)/27)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
l=float(input())
l=pow(l/3,3)
print(l)

Solution (Python):
print((float(input())/3)**3)

Solution (Python):
l = int(input())
print(l ** 3 / 27)

Solution (Python):
a=int(input())
print((a/3)**3)

Solution (Python):
L=float(input())

ans=float((L/3)**3)
print(ans)

Solution (Python):
l=int(input())



ans=l**3/27
print('{:.11f}'.format(ans))

Solution (Python):
import sys
val = float(sys.stdin.readline().rstrip())
print('%.6f' % (val / 3.0) ** 3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L = int(input())
print( (L/3) ** 3 )

Solution (Python):
l=int(input())
print((l/3)**3)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L = int(input())

print((L / 3) ** 3)

Solution (Python):
L = int(input())



max = (L)*(L)*(L)/27
print(max)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
l = int(input())
res = (l/3)**3
print(res)

Solution (Python):
l = int(input())

sideLength = l/3
print(sideLength**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
l = int(input())
d = l/3
print(d**3)

Solution (Python):
print((int(input())/3)**3)

Solution (Python):
L = int(input())
print((L/3)**3)

Solution (Python):
print(pow(int(input()), 3)/27)

Solution (Python):
l=int(input())
print(l*l*l/27)

Solution (Python):
l = int(input())

print((l/3)**3)

Solution (Python):

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

Solution (Python):
L = int(input())

ans  = (L/3) ** 3
print(ans)

Solution (Python):
l = int(input())

print((l/3)**3)

Solution (Python):
from decimal import Decimal
L = int(input())

l = Decimal(L) / Decimal(3)

print(Decimal(l) * Decimal(l) * Decimal(l))

Solution (Python):
print(pow(int(input()) / 3, 3))

Solution (Python):
import numpy as np
L = int(input())
ans = (L / 3)**3
print(ans)

Solution (Python):
N = int(input())

print((N/3)**3)

Solution (Python):
L = int(input())

print((L / 3)**3)

Solution (Python):
print(int(input())**3/27)

Solution (Python):
l = int(input())
print((l/3)**3)

Solution (Python):
L = int(input())

print((L/3)**3)