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=float(pow(L,3)/27)
print(ans)

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

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

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):
def main():
    L = int(input())
    V = (L/3)**3
    print(V)

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):


from sys import stdin, stderr

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

   L3 = L / 3.0
   res = L3 * L3 * L3
   print(res)

   return 0

if __name__ == '__main__': main()

Solution (Python):

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


if __name__ == "__main__":
    main()

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

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

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

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

a=b=c=l/3

s=a*b*c

print(s)

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

Solution (Python):

import collections


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


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

Solution (Python):



L = int(input())


def main():
    x = L / 3
    ans = x ** 3
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    L = int(input())
    l = L / 3
    print(l ** 3)
resolve()

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

L = INT()

print((L/3)**3)

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

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

Solution (Python):
l = int(input())
a = l/3
ans = a**3
print(round(ans,13))

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

Solution (Python):

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

Solution (Python):


L = int(input())

length = L / 3

V = length**3

print(V)

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

print(L*L*L/27)

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

Solution (Python):

from sys import stdin
from operator import itemgetter


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

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

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

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

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

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

if __name__ == "__main__":
    resolve()

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

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

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

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

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

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

def Volume(q):
  x,y=q
  x=abs(x)
  y=abs(y)
  z=L-x-y
  return -x*y*z

from scipy.optimize import fmin
res=fmin(Volume,(0,0),xtol=1e-8,ftol=1e-8,disp=0)
print(-Volume(res))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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())
s=float(l/3)
print('{:.7f}'.format(s**3))

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

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

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

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

Solution (Python):

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

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

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

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

ans = input_line/3
ans = ans**3

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

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):
n=int(input());
print(n/3 * n/3* n/3);

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

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

print((l / 3) ** 3)

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

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

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

Solution (Python):

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

Solution (Python):
'''input
999
'''
l = int(input())
d = l / 3
print(round(d ** 3, 6))

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

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):
from sys import stdin,setrecursionlimit
n = int(stdin.readline().rstrip())
print((n/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):
l=int(input())
print((l/3)**3)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
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()
    print((l/3)**3)
    return


if __name__ == "__main__":
    solve()

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

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

print (L**3/27)

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

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

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

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

if __name__ == '__main__':
    resolve()

Solution (Python):
import math
L = float(input())
m = float((L/3)**3)
print('{:.12f}'.format(m))

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

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

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

Solution (Python):
sel='C'

if sel=='A':
    N,M=map(int,input().split())
    ans=0
    ans+=M*(M-1)//2
    ans+=N*(N-1)//2
    print(ans)


if sel=='B':
    def ispal(s):
        for i in range(len(s)//2+1):
            if s[i]!=s[-(i+1)]:
                return False
        return True

    S=input()
    if ispal(S) and ispal(S[:(N-1)//2]) and ispal(S[(N+3)//2-1:]):
        print('Yes')
    else:
        print('No')


if sel=='C':
    L=int(input())
    print((L**3)/27)


if sel=='D':    
    N=int(input())
    A=[int(i) for i in input().split()]
    kin=list(set(A))
    cnt={}
    for k in kin:
        cnt[k]=0
    for a in A:
        cnt[a]+=1
    SUM=0
    for k in kin:
        SUM+=cnt[k]*(cnt[k]-1)//2
    for a in A:
        if cnt[a]>=2:
            print(SUM-cnt[a]+1)
        else:
            print(SUM)
        

if sel=='E':
    a=0


if sel=='F':
    N,S=map(int,input().split())
    A=[int(i) for i in input().split()]

    for l in range(N):
        for r in range(l,N):
            print(tab[l][r])

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

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

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

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

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

Solution (Python):
import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
from io import BytesIO, IOBase
from bisect import bisect_left as bl
from bisect import bisect_right as br 




def sieve(n):
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r
 
def divs(n, start=1):
    divisors = []
    for i in range(start, int(math.sqrt(n) + 1)):
        if n % i == 0:
            if n / i == i:
                divisors.append(i)
            else:
                divisors.extend([i, n // i])
    return divisors
 
def divn(n, primes):
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t

def flin(d, x, default=-1):
    left = right = -1
    for i in range(len(d)):
        if d[i] == x:
            if left == -1: left = i
            right = i
    if left == -1:
        return (default, default)
    else:
        return (left, right)

def modpow(b,p,m):
    res=1
    b=b%m
    while(p):
        if p&1:
            res=(res*b)%m
        b=(b*b)%m
        p>>=1
    return res

def mod_inv(a,m):
    return modpow(a,m-2,m)

def ncr(n,r,m):
    res=1
    if r==0:
        return 1
    if n-r<r:
        r=n-r
    p,k=1,1
    while(r):
        res=((res%m)*(((n%m)*mod_inv(r,m))%m))%m
        n-=1
        r-=1
    return res

def ncrlis(n,r,m,fact):
    return (fact[n]*(mod_inv(fact[r],m)*mod_inv(fact[n-r],m))%m)%m

def dfs(u,lis):
    vis[u]=True
    lis.append(u)
    for v in g[u]:
        if not vis[v]:
            lis=dfs(v,lis)
    return lis
def dfsutil():
    cnc=[]
    for i in range(1,n+1):
        if not vis[i]:
            tmp=[]
            cnc.append(dfs(i,tmp))
    return cnc

def bfs(s,prev):
    q=deque()
    q.append(s)
    vis[s]=True
    while q:
        u=q.popleft()
        for v in g[u]:
            if not vis[v]:
                q.append(v)
                vis[v]=True
                
                prev[v]=u
def path(s,e):
    prev=[False for i in range(n+1)]
    bfs(s,prev)
    at=e
    res=[]
    while at!=False:
        res.append(at)
        at=prev[at]
    res.reverse()
    if res[0]==s:
        return res
    else:
        return []


def ceil(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def ddd(): return collections.defaultdict(collections.defaultdict(int))
 
 

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

'''def isPalindrome(s):
    return s==s[::-1]

for _ in range(ii()):
    s=input()
    n=len(s)
    d=ddl()
    for i in range(n):
        d[s[i]].append(i)
    a=''
    idx=-1
    for i in range(len(s)):
        if s[i]==s[n-1-i]:
            a+=s[i]
        else:
            idx=i
            break
    if idx==-1:
        print(s)
        continue
    idx2,idx3=-1,-1
    ch1,ch2=s[idx],s[n-idx-1]
    f1,f2=False,False
    if len(d[ch1])>1:
        for i in range(1,len(d[ch1])-1):
            if d[ch1][i+1]
    if idx2!=-1:
        f1=isPalindrome(s[idx:idx2+1])
    if idx3!=-1:
        f2=isPalindrome(s[idx3:n-idx])
    l1,l2=idx2-idx+1,n-idx-idx3
    if f1 and f2 and l1>=l2:
        print(a+s[idx:idx2+1]+a[::-1])
    elif f1 and f2 and l1<l2:
        print(a+s[idx3:n-idx]+a[::-1])
    elif f1:
        print(a+s[idx:idx2+1]+a[::-1])
    elif f2:
        print(a+s[idx3:n-idx]+a[::-1])
    else:
        print(a+s[idx]+a[::-1])'''

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

Solution (Python):
L = float(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):
import sys
input = sys.stdin.readline

L = int(input())

print((L/3)**3)

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

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

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

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

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

x = L / 3 
y = x
z = x

print (x * y * z)

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

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

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

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

Solution (Python):
import math
n = int(input())
a = n**3
b = float(a/27)
print(b)

Solution (Python):
import math
from decimal import Decimal

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

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

Solution (Python):
L = int(raw_input())
x = round(float(L)/3, 6)
print(x*x*x)

Solution (Python):
import numpy as np

x = np.float128(input())

print(np.power(x/3, 3))

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

V = (y * ((y - L) ** 2)) / 4
print(V)

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

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

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

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

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

Solution (Python):

import sys
import itertools


from operator import itemgetter
from sys import stdin


N=3
M=3
i=0
j=0
k=0
x=0
y=0
z=0
xy=0
V=0
c=[]
number_list=list(map(int, input().split(" ")))
L=number_list[0]


z=0.25*L
z1=0.75*L
for i in range(10**12):
    z += i*(10**(-12))*L
    if z>z1:
        break
    
    V1=((L-z)**2)/4*z
    c.append(float(V1))
    
    

print(max(c))





"1行1つの整数を入力を取得し、整数と取得する"




"12 21 332 とか入力する時に使う"
"1行に複数の整数の入力を取得し、整数として扱う"

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

for i in number_list:
    print(number_list[i-1])

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'''
x=[]
y=[]
for i in range(N):
    x1, y1=[int(i) for i in input().split()]
    x.append(x1)
    y.append(y1)
print(x)
print(y)
"複数行に2数値を入力する形式 x座標とy座標を入力するイメージ"
'''

'''
mixlist=[]
for i in range(N):
    a,b=input().split()
    mixlist.append((int(a),b))
print(mixlist)
"複数行にintとstrを複合して入力するやつ，今回はリスト一つで処理している"
'''

'''



"正方行列にstr型の値を入力"
'''




'''
入力
1 2
4 5
7 8
出力結果
[[1, 2], [4, 5], [7, 8]]
'''
"列数に関して自由度の高いint型の値を入力するタイプの行列"


'''
table = [[int(i) for i in input().split()] for m in range(m)]

print(type(N))
print(N)
print(type(M))
print(M)

print(type(table))
print(table)
'''











'''
入力
1234
出力
1
[[1, 2, 3, 4]]
'''




'''
word_list= input().split(" ")
print(word_list[0])
"連続文字列の入力"
"qw er ty とかの入力に使う"
"入力すると空白で区切ったところでlistの番号が与えられる"
'''



'''
A, B, C=stdin.readline().rstrip().split()
print(A)
"リストではなく独立したstr型を入れるなら以下のやり方でOK"
'''




"aという変数に入っているものを大文字にして出力"

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

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

Solution (Python):

L = int(input())
l = float(L/3).as_integer_ratio()

x = l[0]
y = l[1]
xxx = x**3
yyy = y**3
print(xxx/yyy)

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

s = n//3
t = n % 3

if n >=3:
    if t == 0:
        print(s**3)
    else:
        print((n/3)**3)
else:
    if n == 1:
        print(0.333333333333333**3)
    else:
        print(0.666666666666666**3)

Solution (Python):
from decimal import *

l = int(input())

one_side_len = Decimal(l) / Decimal(3)

print(Decimal(one_side_len)*Decimal(one_side_len)*Decimal(one_side_len))

Solution (Python):

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

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

print(L*L*L/27)

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

num = num/3
num = num**3
print(num)

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

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

print(max)

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

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

Solution (Python):
L = input()
dist = float(L) / 3

print(dist*dist*dist)

Solution (Python):
import numpy as np

L = int(input())

l = [0, 0]
for c in np.arange(0, L, 0.001):
    s = (((L-c)**2)/4)*c
    if c == 0:
        l[0] = s
    else:
        l[1] = s
        if l[0] >= l[1]:
            ans = l[0]
            break
        l[0] = l[1]
    

print(ans)

Solution (Python):
import decimal
A = int(input())
a = decimal.Decimal(A)
b = A / 3
c = b ** 3
print(c)

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

Solution (Python):
from decimal import Decimal

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

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

if __name__ == '__main__':
    main()

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

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

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

x=y=z=0

x=y=z=L/3

V = x*y*z




print(V)

Solution (Python):

L = int(input())

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

Solution (Python):
from decimal import * 
l = int(input())

v_m = Decimal(str((l/3)**3))
print(v_m)

Solution (Python):
import decimal


l = int(input())
a,b,c = 0,0,0
a = decimal.Decimal(l/3)
b = decimal.Decimal(l/3)
c = decimal.Decimal(l/3)
 
print(a*b*c)

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

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

Solution (Python):
L = int(input())
if L % 3 == 0:
  b = [i + 1 for i in range(L)]
  k = [(i * (L - i) * (L - i)) / 4 for i in b]
  print(max(k))
else: 
  import numpy as np
  b = np.arange(0.1, L+0.005, 0.005)
  k = [(i * (L - i) * (L - i)) / 4 for i in b]
  print(max(k))

Solution (Python):
L = float(input())
print("{:.10f}".format(pow(L / 3, 3)))

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

Solution (Python):
L = int(input())
'''
x
y
z

x + y + z = L
max: x * y * z
'''

temp = L / 3
V = temp ** 3

print(V)

Solution (Python):


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

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

Solution (Python):

L=int(input())
tmp2=0
x=0
float(x)
x=L/3
tmp2=x**3

print(tmp2)

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

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

if L == 1:
    print('0.037036926')
elif L==2:
     print('0.296296074')
else:
    ans =0
    for i in range(100000):
        ans =max(ans, i/100*i/100*(L-(i/100+i/100)))
    print(ans)

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

Solution (Python):
a = list(map(int, input().split()))
b = a[0]/3
c = b**3
print(c)

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

s=float(L)/3

print(pow(s ,3))

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

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

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

print(HWL ** 3)

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

Solution (Python):

import math
n = int(input())




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

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

Solution (Python):
def main():
  a = []
  n = int(input())
  print((n/3)**3)

  
def count_section_by_zero(data):
  count = 0
  flg = False
  start = 0
  for i, d in enumerate(data):
    if flg is False and d != 0:
      count += 1
      flg = True
      
    if d == 0:
      flg = False
  return count

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

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

def input_list_str():
  return map(str, input().split())

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)


def divide_two(arg):
  c = 0
  while True:
    if c >= 2:
      break
    if arg % 2 != 0:
      break
    arg //= 2
    c += 1
  return c


def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

import math
import fractions
import collections
from functools import reduce
main()

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

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

jud = float(a/3) ** 3

print(jud)

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

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

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

Solution (Python):
L=input()
L=int(L)
if 1<=L<=1000:
    a=L**3
    V=a/27
    print(V)

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

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


print((L/3.0)**3)

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

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

print((L/3)**3)

Solution (Python):


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

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

a,b,c=[L/3,L/3,L/3]

V=a*b*c

print(V)

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

a = l/Decimal(3)

print(a*a*a)

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

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

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

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

print(l**3 / 27)

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

print(round((n / 3) ** 3, 8))

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

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

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

def f(x):
    return x * x * (l - 2 * x)

print(max(f(l / 3), f(0)))

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

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

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

Solution (Python):
import decimal

L = int(input())
decimal.getcontext().prec = 12
L = decimal.Decimal(L)
p = decimal.Decimal(3)
l = L / p
print(l**p)

Solution (Python):

l=int(input())

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

for ll in range(l//3):
    if ((l/3)+ll)*(l/3)*((l/3)-ll)>v:
        v= ((l/3)+1)*(l/3)*((l/3)-1)

print(v)

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

Solution (Python):
import decimal

def volume(h, w, v):
    return h * w * v

L = decimal.Decimal(input())

i = decimal.Decimal(L/3)
j = decimal.Decimal(L/3)
k = decimal.Decimal(L/3)
max_volume = volume(i, j, k)
while k <= decimal.Decimal(L/3) + 1:
    if i + j + k > L:
        k += decimal.Decimal(0.01)
        continue
    v = volume(i, j, k)
    max_volume = max(max_volume, v)
    k += decimal.Decimal(0.01)

print(max_volume)

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

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

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

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

count = w * w * w
print(Decimal(count).quantize(Decimal('0.000000000001'), rounding=ROUND_HALF_UP))

Solution (Python):
import math
import numpy as np

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

print(a0*a0*a0)

Solution (Python):
import decimal

L=int(input())


x = decimal.Decimal(L / 3)

V=decimal.Decimal(x*x*x)

print("{:.12f}".format(V))

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

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

print((L / 3)**3)

Solution (Python):
import decimal
decimal.getcontext().prec = 6

L = int(input()) 

vertical = L / 3.0
horizontal = L / 3.0
height = L / 3.0

print(vertical * horizontal * height)

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

x=L/3

print(round(x*x*x,7))

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

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

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

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

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

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

m = n/3
print(m*m*m)

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

Solution (Python):
def maxvolume(s):  
    length = s / 3
    s -= length 
    breadth = s / 2
    height = s - breadth 
      
    return "{:.12f}".format(length * breadth * height) 
s = int(input())
print(maxvolume(s))

Solution (Python):
L = float(input())
M = float(L/3)
print('{:.12f}'.format(M**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):
def main():
    L = int(input())
    r = L / 3
    V = r ** 3
    print(V)
    return

if __name__ == '__main__':
    main()

Solution (Python):
import math

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

Solution (Python):
l=int(input())
ans=l*l*l
ans=ans/27
print("%.18f"%(ans))

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

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

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

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

Solution (Python):
s = int(input())
a = s/3
b, c = a, a
ans = float(a*b*c)
print(ans)

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

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

Solution (Python):
import sys; sys.setrecursionlimit(2147483647); input = sys.stdin.readline
from math import floor, ceil, sqrt, factorial, log
from collections import Counter, defaultdict, deque
from operator import itemgetter
INF = float('inf'); MOD = 10**9+7
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(MI())
def LIR(n): return [LI() for i in range(n)]
def IS(): return input().rstrip()

def main():
    L = I()
    print((L/3)**3)
if __name__ == '__main__':
    main()

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

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