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())
l3 = l/3
print(l3**3)

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

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

a = L / 3

print(a ** 3)

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

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

print((n/3)**3)

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

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

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

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

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

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

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

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

tmp = L / 3

print(tmp * tmp * tmp)

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

V = (L / 3) ** 3

print(V)

Solution (Python):
l = int(input(""))
t = l / 3.0
print(t*t*t)

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

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

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

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


hen=L/3

print(hen**3)

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):

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

Solution (Python):

L = int(input())


print(L*L*L/27)

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

Solution (Python):





def main():
    inp = lambda: [int(x) for x in input().split()]
    n = float(input()) / 3
    print(n ** 3)

if __name__ == '__main__':
    main()

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

Solution (Python):
l=int(input())
a=l/3
a=pow(a,3)
print('{0:.12f}'.format(a))

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

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

print(a*b*c)

Solution (Python):

import sys


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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    solve(L)

if __name__ == '__main__':
    main()

Solution (Python):

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

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

a = l/3

print(a**3)

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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

L = i_i()

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

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

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

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

print((n/3)**3)

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

a = L / 3

print(a**3)

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

Solution (Python):
import decimal
    
num = decimal.Decimal(input())
calc_num = decimal.Decimal(num / 3)
print(calc_num * calc_num * calc_num)

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

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

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

Solution (Python):




def maxvolume( s ): 

	
	length = (s / 3) 
	
	s -= length 
	
	
	breadth = s / 2
	
	
	height = s - breadth 
	
	return (length * breadth * height) 
	

s = int(input())
print( maxvolume(s) )

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

w = n/3
h = n/3
t = n - n/3 - n/3

print(w * h * t)

Solution (Python):

L = int(input())

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

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

Solution (Python):
from decimal import Decimal
L = float(input())
ans = Decimal((L/3)**3)
print('{:.12f}'.format(ans))

Solution (Python):
L = int(input())
m = L*1000000//3
volume = m/1000000*m/1000000*(L*1000000-2*m)/1000000
print(volume)

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

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

a=L/3

ans=a*a*a

print(ans)

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


print((L/3)**3)

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

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

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

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

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

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

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

print((l/3) ** 3)

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

Solution (Python):
l = int(input())
print((l/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())

one = L/3

answer = one*one*one

print(answer)

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

e = l/3
ans = e**3
print("{:.12f}".format(ans))

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

print((l/3)**3)

Solution (Python):

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

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

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())
x = L/3
y = L/3
z = L/3

print(x*y*z)

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



print((l/3)**3)

Solution (Python):
from decimal import *

L = int(input())
ans = Decimal((L / 3) ** 3)

print('{:.10g}'.format(ans))

Solution (Python):
from decimal import Decimal
from decimal import *

getcontext().prec = 40

L = Decimal(str(input()))

factor = L / Decimal("3")

print(factor**Decimal("3"))

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    l = int(input().strip())
    result = (l / 3.0) ** 3
    print(result)




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

n = int(input())

if (n/3)*3 == n:
    print((n/3) * (n/3) * (n/3))

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

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

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

from decimal import *

getcontext().prec=100

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

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

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

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

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

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

Solution (Python):


MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

L = int(input())

ans = float(L)/3

print(ans*ans*ans)

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

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

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

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

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

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

    return

if __name__ == "__main__":
    main()

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

Solution (Python):
import sys, math

sys.setrecursionlimit(10 ** 9)
from collections import defaultdict

IA = lambda: map(int, input().split())
IAS = lambda: map(str, input().split())

sum=0
for i in range(10):
    sum+=1
n = int(input())
print("{:.12f}".format(pow(n, 3) / 27.0))

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

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

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

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

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

print((L/3)**3)

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

import math
a=math.floor(l/3*100000000000000000)/100000000000000000
b=math.floor(l/3*100000000000000000)/100000000000000000
c=l-a-b

print(a*b*c)

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

print((L/3) ** 3)

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

Solution (Python):
import decimal
print((decimal.Decimal(input()) / 3) ** 3)

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

x = l / 3
y = l / 3
z = l / 3

ans = x * y * z

print('{:.12f}'.format(ans))

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

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

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

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

print((L**3)/27)

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

print((L/3)**3)

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

a = l/3

print(a**3)

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

ans = (L/3) ** 3

print(ans)

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

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

A = L/3
A = round(A, 9)

print(A ** 3)

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

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

print((l/3)**3)

Solution (Python):




l = int(input())


wkl = l / 3
ans = wkl ** 3


print(ans)

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

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

Solution (Python):
from decimal import Decimal

n = int(input())
print(Decimal(n/3)**3)

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

n = int(readline())

p = n/3

print(p**3)

Solution (Python):

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

Solution (Python):




import sys
input = sys.stdin.readline



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

    x = L / 3

    V = x ** 3

    print(V)



main()

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

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

Solution (Python):
import sys


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

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

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

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

Solution (Python):

import sys


def solve(L: int):
    print(format((L/3.0)**3.0, ".10f"))



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    solve(L)

if __name__ == '__main__':
    main()

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

Solution (Python):
L = int(input().rstrip())
import decimal
decimal.getcontext().prec = 30
L = decimal.Decimal(L)
a = L / 3
print(a*a*a)

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

Solution (Python):
import bisect, collections
 
 
 
def solution():
    l = int(input().strip())
    print((l/3)**3)
    

def main():    
    
    for _ in range(1):
        solution()

if __name__ == "__main__":
    main()

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

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

Solution (Python):




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


if __name__ == "__main__":
    main()

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

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

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

print(data ** 3 / 27)

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

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

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

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

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

print(a*a*a)

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())
V = L/3 * L/3 * L/3
print(V)

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

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

print('{:.12f}'.format((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):
n = int(input())
print(n**3 / 27)

Solution (Python):
def Main(L):
    return (L/3)**3
    

def main():
    L = int(input())
    print("{:.12f}".format(Main(L)))

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import decimal
def solve():
  decimal.getcontext().prec = 10
  l = int(input())
  l = decimal.Decimal(l)
  huga = decimal.Decimal(3)
  hoge = l / huga
  print(hoge ** huga)
  return 0

if __name__ == "__main__":
  solve()

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

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

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

side = L / 3

print(side**3)

Solution (Python):


l = int(input())

a = l/3
b = l/3
c = l - (a+b)

print(a*b*c)

Solution (Python):

import sys
def input():
    return sys.stdin.readline().rstrip()

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

    print((L/3)**3)
    



if __name__ == '__main__':
    main()

Solution (Python):



from decimal import Decimal

l = Decimal(input())

ans = (l / Decimal(3.0)) ** Decimal(3.0)

print(ans)

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

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

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

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

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

print((n/3)**3)

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

print(ans)

Solution (Python):
from decimal import Decimal

n = int(input())

a = Decimal(n/3)

print(a**3)

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

a = L/3
V = a**3

print(V)

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

print((s/3)**3)

Solution (Python):
s = int(input())
print("%.6f" % (s**3/27))

Solution (Python):
def main():
    sum_l = float(input().strip())

    l = sum_l / 3
    ans = l ** 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):
N = int(input())

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

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

print((L/3)**3)

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

Solution (Python):
from sys import stdin


def get_result(data):
    L = data[0]
    return pow((L/3.0), 3.0)


if __name__ == '__main__':
    data = list(map(int, stdin.readline().split(' ')))
    result = get_result(data)
    print(result)

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

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())

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

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

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

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

Solution (Python):


l = int(input())


s = l / 3


print(s**3)

Solution (Python):




def maxvolume( s ): 

	
	length = s / 3 
	s -= length 
	
	breadth = s / 2
	
	height = s - breadth 
	
	return length * breadth * height
	

s = int(input())
jj=maxvolume(s)
print ('%.15f'%jj)

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

print(l ** 3 / 27)

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

L1 = L/3
L -= L1
L2 = L/2
L -= L2
print(L1*L2*L)

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

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

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

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

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

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

Solution (Python):
l = float(input())
print('{:.10f}'.format((l/3)**3))

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

l1 = L / 3
l2 = L / 3
l3 = L - l1 -l2

print(l1 * l2 * l3)

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

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

def f(x,y):
    z = l-x-y
    if z<0 or z>l:
        print(x,y,z)
        return -1
    return x*y*z

def fp(x,y):
    dx = y*(l-x-y) - x*y
    dy = x*(l-x-y) - x*y
    return dx,dy

x = 1.0
y = 1.0
while True:
    dx,dy = fp(x,y)
    if abs(dx)<10**-6 and abs(dy)<10**-6:
        print(f(x,y))
        exit()

    x += dx * 10**-5
    y += dy * 10**-5

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







print((l/3)**3)

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

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

Solution (Python):

from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left

def L():
    return list(map(int, stdin.readline().split()))

def In():
    return map(int, stdin.readline().split())

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

P = 1000000007
l = I()
a = l/3
print('%.12f'%(a*a*a))

Solution (Python):

import sys


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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    solve(L)

if __name__ == '__main__':
    main()

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

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

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

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


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

    return x ** 3


print(main(L))

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

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

Solution (Python):
import numpy as np
import fractions
import decimal
from collections import deque

n=float(input())
a=n/3
b=n/3
c=n/3

print(a*b*c)

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

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

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

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

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

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

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):
def main():

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


if __name__ == '__main__':
    main()

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

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

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

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

a = L/3
b = L/3
c = L -a-b

print(a*b*c)

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

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

Solution (Python):
def main():
    l = int(input())
    mx = 0
    hen = l / 3
    print(hen**3)


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    L = int(input())

    ans = (L / 3) ** 3

    print(ans)

    
if __name__ == "__main__":
    main()

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

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

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

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

ans = 0
i = 0
while i < l:
    if (l - i) % 2 == 0:
        a = (l - i) / 2
        b = (l - i) / 2
    else:
        a = ((l - i) / 2)
        b = (l - i) / 2
    ans = max(ans, a * b * i)
    i += 0.001

print(ans)

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

print((L/3)**3)

Solution (Python):


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

Solution (Python):
inputs = list(map(int, (input().split())))

n = inputs[0]

print((n/3)**3)

Solution (Python):
if __name__ == "__main__":
    l = int(input())
    m = (l/3)**3
    print(m)

Solution (Python):
if __name__ == '__main__':
	L = int(input())

	ans = (L/3)**3

	print(ans)

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

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

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

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

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

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

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

a = float(l/3)

print(a**3)

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

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

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

print((l / 3) ** 3)

Solution (Python):

import os
import sys
from io import BytesIO, IOBase
from math import ceil

def main():
    s = int(input())
    length = s / 3; 
  
    s -= length; 
  
    breadth = s / 2; 
    height = s - breadth; 
    print(length*breadth*height)







BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline

from decimal import *

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




def main():
	L = inputInt()

	tmp = L / 3

	print(tmp*tmp*tmp)







def int_sqrt2(n):
    def f(prev):
        while True:
            m = (prev + n / prev) / 2
            if m >= prev:
                return prev
            prev = m

    return f(int(math.sqrt(n) * (1 + 1e-10)))



def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

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

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

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

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

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

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

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

Solution (Python):
import sys,math
sys.setrecursionlimit(10**9)
from collections import defaultdict
 
IA = lambda: map(int,input().split())
IAS= lambda: map(str,input().split())

n=int(input())
print("{:.12f}".format(pow(n,3)/27.0))

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








print(L**3/27)

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

x=L/3
y=x
z=L-x-y

print(x*y*z)

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

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

Solution (Python):
N = int(input())
N_1 = round(N/3, 6)
N_2 = round(N/3, 6)
N_3 = round(N/3, 6)

if N_1+N_2+N_3!=N:
  N_3 += N-(N_1+N_2+N_3)
print(N_1*N_2*N_3)

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

print((n/3)**3)

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

Solution (Python):
from fractions import Fraction
l = int(input())
a = (l/3)
print(a**3)

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

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

Solution (Python):
def solve(L):
    x = L/3.0
    print(x*x*x)

L = int(input())
solve(L)

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())
print((L/3)**3)

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

print((l / 3) ** 3)

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

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

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

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

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

Solution (Python):
from decimal import *
getcontext().prec = 16

L = int(input())

dec_var = Decimal(L / 3)
print(Decimal(dec_var ** 3))

Solution (Python):
s = int(input())
l = s/3
s-=l
b = s/2
h = s-b
print(l*b*h)

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

Solution (Python):
l = int(input())
print("{:.9f}".format((l / 3) ** 3))

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

a = L/3

print("%.10f" % a**3)

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