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):
from decimal import *
import math
getcontext().prec = 30
n = int(input())
nd = Decimal(n**1/3)
print(float(Decimal(nd**3)))

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

print(L**3/27)

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

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

a = float(L/3)

print(a**3)

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

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

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

Solution (Python):


import sys

sys.setrecursionlimit(10 ** 6)


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

main()

Solution (Python):



l = int(input())

print((l/3)**3)

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

print((l/3)**3)

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

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

Solution (Python):
import sys
from decimal import *
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


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


main()

Solution (Python):
import re
from decimal import Decimal, ROUND_DOWN

print((Decimal(input()) / 3) ** 3)

Solution (Python):

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

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

a = num/3
ans = float(a) ** 3
print('{:.12f}'.format(ans))

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

    print((L/3)**3)

if __name__ == "__main__":
    main()

Solution (Python):
import math
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):
import math
L=int(input())
print((L/3)**3)

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

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
l = int(input())
ans1 = l/3
print(ans1**3)

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

print((L/3)**3)

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

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

Solution (Python):
def c():
    L = int(input())
    a, b = (L/3, L/3)
    c = L - (a + b)

    print(a * b * c)



if __name__ == "__main__":
    c()

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*L*L/27)

Solution (Python):
L = int(input())
l = L//3
'''
ans = (L//3)**3
if L % 3 == 0:
    print(ans)
    exit()j
elif L % 3 == 1:
    for i in range(1000001):
        for j in range(1000000-i):
            ans=max(ans,ans+l*l*(0.000001*()))
'''
print((L/3)*(L/3)*(L/3))

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

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

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

Solution (Python):



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


if __name__ == '__main__':
    main()

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

L /= 3

print(L*L*L)

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

Solution (Python):


l = [0]

def format_input(filename = None):
	global l
	if filename == None:
		l = int(input())

	elif filename == '__random__':
		from random import randint as rng
		l = rng(1, 10**3)

def get_answer():
	answer = (l/3)**3
	return answer

if __name__ == '__main__':
	format_input()

	ans = get_answer()
	print(ans)

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

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

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

print(l**3/27)

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

print ((L/3.0)**3)

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

n = N/3

print(n**3)

Solution (Python):
a=float(input())
print(a/3*a/3*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())
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 math import ceil, floor, pow
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

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())
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):
l = int(input())

print((l / 3) ** 3)

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

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

Solution (Python):

l = int(input())

s = l/3
result = s*s*s

print(result)

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

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

Solution (Python):
import math
import string


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


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


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]


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

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

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

Solution (Python):

L = int(input())
print(pow((L/3),3))

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

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

t = L / 3

print(pow(t, 3))

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

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

ans = l**3 / 27

print('%6f'%ans)

Solution (Python):
import itertools,sys,collections,math,random,fractions,bisect;sys.setrecursionlimit(10**7)
sr = sys.stdin.readline; P = print; P2 = lambda x: print(*x, sep="\n")
def I(i=0): t = [int(x)-i for x in sr().split()];return t
def S(): t = sr().split(); return t if len(t) > 1 else t[0]
L1,L2,L3,L4, = [],[],[],[]

L, = I()
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)

Solution (Python):



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

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

a = l / 3

print(a ** 3)

Solution (Python):
import math

L = int(input())

x = math.floor(L/3*1e7)/1e7
print(x**3)

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

print((L/3)**3)

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

Solution (Python):
from decimal import Decimal

L=Decimal(int(input()))
h=L/Decimal(3)
w=L/Decimal(3)
t=L/Decimal(3)

print(h*w*t)

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

print((l/3)**3)

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

Solution (Python):
L = int(input())
hen = L/3
A = (L/3)**3
print(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/27)

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

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

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

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

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

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

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




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




l=int(input())
if l%3==0:
    print((l//3)**3)
elif l%3==1:
    print((l/3)**3)
else:
    print((l/3)**3)

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

print((S/3)**3)

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	L = II()
	x = L/3
	y = L/3
	print(y*x*(L-x-y))




if __name__ == '__main__':
	main()

Solution (Python):
def calculate(N):
    print(N**3 / 27)

calculate(int(input()))

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

Solution (Python):
import numpy as np
L = int(input())
print(float(np.longdouble((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())

"""
max = 0
for a in range(L - 2 , 0, -1):
    for b in range(L - a, 0, -1):
        c = L - a - b
        if a * b * c > max:
            max = a * b * c
print(max)
"""

print((L/3) ** 3)

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

y = x / 3

print(y**3)

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

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

a = L/3
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*L*L/27)

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

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

Solution (Python):
n = int(input())
print((n/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())
ans = (N/3)**3
print(ans)

Solution (Python):

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

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

print(L**3/27)

Solution (Python):
'''
.append(要素) リストに要素を追加
.extend(リスト) リストを連結する
.insert(場所,要素) 指定した場所に要素追加
del 配列名[場所]
-1で末尾で末尾から一つ前

sort()
sorted(reverse=true)

配列の初期化
配列名=[a]*n+[b]*m

Decimal()
'''

from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
from functools import reduce
from operator import mul
from collections import Counter


def ispalindrome(str): return 1 if str == str[::-1] else 0


n = float(stdin.readline().rstrip())


print((n/3)**3)

Solution (Python):

import sys
def p(*_a):
  _s=" ".join(map(str,_a))
  
  sys.stderr.write(_s+"\n")


L = int(input())		

l = L/3

print(l**3)

Solution (Python):


import sys


def LI():
    return list(map(int, sys.stdin.buffer.readline().split()))


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


def LS():
    return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()


def S():
    return sys.stdin.buffer.readline().rstrip().decode('utf-8')


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


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


def MSRL(n):
    return [[int(j) for j in list(S())] for i in range(n)]




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


main()

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

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

print(a**3)

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

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

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

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

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

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

res = (x/3)**3

print(res)

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

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

Solution (Python):


L = int(input())
x = L**3

print(x/27)

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

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





print((L/3)**3)

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

Solution (Python):


import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))


L = I()

ll = L/3

print(ll ** 3)

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

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

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

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

print(a*a*a)

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

print(L**3/27)

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

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

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

ans = x*y*z

print(ans)

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

hen = L/3

print("{:.6f}".format(hen**3))

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

print(pow(L / 3, 3))

Solution (Python):


L = int(input())

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

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

Solution (Python):
import sys

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

print((l**3)/27)

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

Solution (Python):
L = int(input())
epsilon = 10*(10*-7)
if L%3==0:
    length = L/3
    vol = length**3
    print(vol)
else:
    length = L/3
    vol = length**3
    print(vol)

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

print(taiseki)

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

d = Decimal(L)
temp = d / Decimal(3)

ans = float(temp ** 3)
print(ans)

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

print((L / 3) ** 3)

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

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

l_3 = L / 3



print(l_3 ** 3)

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

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

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

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

Solution (Python):

from decimal import Decimal

L = float(input())


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

Solution (Python):
from decimal import *
l = int(input())
a = Decimal(l/3)
volume = a**3
print("{:.12f}".format(volume))

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

if __name__ == "__main__":
    l = int(input())
    print(volume(l))

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

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

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

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

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

x=L/3

print(x**3)

Solution (Python):
import math
import copy
from copy import deepcopy
import sys
import fractions

from functools import reduce

import decimal
import heapq
import collections
import itertools

sys.setrecursionlimit(100001)







def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList




s = float(input())

tmp = decimal.Decimal(s/3)
ans = decimal.Decimal(tmp) * decimal.Decimal(tmp) *decimal.Decimal(tmp)

print("{:.10f}".format(ans))

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

print(L**3/27)

Solution (Python):

import sys

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

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

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

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

Solution (Python):
l = int(input()) 
a = l / 3
b = l / 3
c = l - a - b

v = a * b * c
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):
l = int(input())
print((l/3)**3)

Solution (Python):
S=int(input())
l=S/3

print(l*l*l)

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

Solution (Python):
from decimal import *

L = Decimal(input())
side = (L / 3)

print(side**3)

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

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
a = Decimal(input()) / 3
print(a*a*a)

Solution (Python):
from decimal import *

L = int(input())

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys

L = int(input())

v=L*L*L/27.0

print(v)

Solution (Python):
n=input()
print n*n*n/(27.0)

Solution (Python):
l=float(input())
a=float(l/3.000000)
s=0.000000
s=a*a*a
print(s)

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

hen = l/3

print(pow(hen, 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())
l = L/3
print(l**3)

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

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

print((L/3) ** 3)

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

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

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

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

Solution (Python):
L = float(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):
l = int(input())
a = b = c = l / 3
print(a*b*c)

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

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

Solution (Python):
n=int(input())
if 1:
    v=n-(n//3)*3
    a=(n//3)+v
    print(((n//3)+v/3)**3)

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

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

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

l = n/3
l = l**3
print('{0:.12f}'.format(l))

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

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

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

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

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

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

Solution (Python):


import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


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


if __name__ == "__main__":
    main()

Solution (Python):

L = int(input())

dammy = (L/3)**3

print(dammy)

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


if __name__ == '__main__':
    main()

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

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

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

ans = l ** 3 / 27

print(ans)

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

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

Solution (Python):
print((int(input())/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('{:.10f}'.format((L/3)**3))

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


l = L/3

print(l ** 3)

Solution (Python):
l = int(input())
from decimal import *
getcontext().prec = 500

ippen = Decimal(Decimal(l)/3)
print(Decimal(ippen**3))

Solution (Python):
def solve():
    tl = int(input())

    ans = tl ** 3 / 27
    print(ans)
    return

if __name__ == "__main__":
    solve()

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):
a = int(input())

print((a / 3) ** 3)

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

print((l/3) ** 3)

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

Solution (Python):
import numpy as np

sum_ls = np.asarray(input(), dtype=np.float64)

length = sum_ls / 3

ans = length ** 3

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())
    a, b, c = L / 3, L / 3, L / 3
    if a + b + c != L:
        a += L - (a + b + c)
    print(a * b * c)


if __name__ == '__main__':
    main()

Solution (Python):

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

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

s = l/3

print(s**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
print(n*n*n)

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

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

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

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

Volume = (L/3) ** 3

print(Volume)

Solution (Python):
def main():
    L = int(input())
    Ll = L/3
    print(Ll**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):
l = int(input())
n = l/3
x = n**3
print("{0:.7f}".format(x))

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

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

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

l = L/3

print(l*l*l)

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

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

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

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

print((a/3) * (a/3) * (a/3))

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

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

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

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

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

ans = L**3/27

print(float(ans))

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

def main():
    L=float(input())
    a=L/3
    b=(L-a)/2
    print(a*b*(L-a-b))


if __name__ == "__main__":
    main()

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

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

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

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

ans = L**3 / 27

print(ans)

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

print((L / 3) ** 3)

Solution (Python):

N = int(input().strip())
print((N / 3) ** 3)

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

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

print(L**3 / 27)

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

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

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

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

a = L / 3
print('{:.12f}'.format((L / 3) ** 3))

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

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

Solution (Python):

import sys


def solve(L: int):
    r = L / 3
    print(r ** 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):
L=int(input())
x=L/3
print(x**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(pow(L/3,3))

Solution (Python):
import sys
sys.setrecursionlimit(10000000)


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


if __name__ == '__main__':
    main()

Solution (Python):
n=float(input())
n=n/3
n=(n*n*n)
print('%.12f'%n)

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

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

Solution (Python):
L=int(input())
T=L**3
k=T/27
print('{:9f}'.format(k))

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

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

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : list(map(int, stdin.readline().split()))
sys.setrecursionlimit(10 ** 7)

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

if __name__ == '__main__':
    main()

Solution (Python):



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

    v = (L/3) ** 3

    print(v)


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
l = int(input())

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

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

print(ans)

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

Solution (Python):
from decimal import Decimal

L = Decimal(float(input().strip()))

print("{:.6f}".format(L * L * L / Decimal(27.0)))

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

print((L/3)**3)

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

def cal_rec(x, y, z):
    return x * y * z

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

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

ans = pow(l/3, 3)
print(ans)

Solution (Python):



from math import *
from copy import *
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''
3
'''

def solve(L):
	l = L/3
	w = (L - l)/2
	h = L - w - l
	return l*w*h
	

L = int(stdin.readline())
ans = solve(L)
print("%.10f"%ans)

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

Solution (Python):

s = int(input())
a = s/3
V = a**3
print(V)

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

Solution (Python):

n = int(input())
print((n/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):
import numpy as np
L = np.array(int(input()), dtype='float128')
ans = (L / 3)**3
print(ans)

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

l3 = l/3

ans = l**3/(3**3)

print('%.6f'%ans)

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

Solution (Python):



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


if __name__ == '__main__':
    main()

Solution (Python):

L = int(input())


print((L/3)**3)

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

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

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

print((L/3)**3)

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

    print((l / 3) ** 3)

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

Solution (Python):
import bisect,collections,copy,itertools,math,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

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

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

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

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

Solution (Python):
import sys


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

Solution (Python):
def main():

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





if __name__ == '__main__':
    main()

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

Solution (Python):
i = float(input())
a = i / 3
a = a**3
print('%.12f' % a)

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

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

l = int(input())

x = l / 3
y = l / 3
z = l - (x + y)

print(x*y*z)

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

print( (L/3)**3 )

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

K =a**3/27
print(K)