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

print((l/3)**3)

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

print((l/3)**3)

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

l = int(input())

print(solve(l))

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

  print(int(l)**3/27)

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().strip('\n'))
print((L/3)**3)

Solution (Python):



import sys
input = sys.stdin.readline

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

if __name__ == '__main__':
    main()

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

length = L / 3

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

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, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

Solution (Python):
class atcorder:
    
    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('{:.10f}'.format((l/3)**3))

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

b = (a/3)**3

print(b)

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

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

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

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

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

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

Solution (Python):
l = float(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())
V = float((L/3)**3)
print (V)

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

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

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

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

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

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

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    L=int(input())
    print(L**3/27)

if __name__=='__main__':
    main()

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

l = L/3

print(l*l*l)

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

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

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

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

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

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

print((L/3)**3)

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

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

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

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

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

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

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




def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))



from collections import deque

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




if __name__ == "__main__":
	main()

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




def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))



from collections import deque

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




if __name__ == "__main__":
	main()

Solution (Python):
N = float(input())
ans = N*N*N/27.0
print('{:.7f}'.format(ans))

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

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

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

resolve()

Solution (Python):
L = int(input())
y = L/3
x = (L - y)/2
h = L - x - y
print(x*y*h)

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

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

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

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

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

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

print(a*b*c)

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

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

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

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

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

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

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

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


volume = L ** 3 / 27

print(volume)

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

volume = (L / 3) * (L / 3) * (L / 3)

print(volume)

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

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

print(S)

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

print((L/3)**3)

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

"""

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

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

Solution (Python):

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

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

Solution (Python):
def main():
    args = input().rstrip().split(' ')
    L = float(args[0])
    l = L/3.
    print(l*l*l)
    
if __name__ == "__main__":
    main()

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, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
L = INT()
print((L/3)**3)

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def maximum(l):
    print(pow(l/3.0, 3))

l = int(input())

maximum(l)

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

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

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

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

def main():
    l = int(input())
    print(solve(l))


if __name__ == '__main__':
    main()

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

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

x = L/3

print(x*x*x)

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

a = l / 3

v = a ** 3
print(format(v, '.12f'))

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

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

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

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



def in_int():
    return (int(input()))


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


def in_str():
    s = input()
    return (list(s[:len(s) - 1]))


def in_ints():
    return (map(int, input().split()))






n = in_int()

n = n/3


print(n*n*n)

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

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

Solution (Python):
n = int(input())
x = n/3
y = pow(x,3)
print("{0:.12f}".format(y))

Solution (Python):
def short(S):
    a = S/3
    return (a **3)


S =int(input())
print(short(S))

Solution (Python):
def shortie (L):
 R= L/3
 return (R**3)

L=int(input())
print(shortie (L))

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

Solution (Python):
a=int(input())
ans=[]

x =((1000*a)/3)
print((x**3)/1000000000)

Solution (Python):
l=float(input())
if l%3==0:
    print((l//3)**3)
elif l%3==1:
    print(((l//3)+(1/3))**3)
else:
    print(((l//3)+(2/3))**3)

Solution (Python):
def shortie(L):
    r = L/3
    return (r **3)


L =int(input())
print(shortie(L))

Solution (Python):

J = int(input()) 
K = J /3   
M= K
print(M ** 3)

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

Solution (Python):






q = int(input())
w = q / 3
print(w ** 3)

Solution (Python):

H = int(input())
E = H / 3
print(E ** 3)

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

Solution (Python):


a = int(input())

l = a/3

print(l**3)

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

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):
def main():
    L = int(input())

    i = L/3

    print(i*i*i)

main()

Solution (Python):
def maxVolume(dim):
	return dim * dim * dim / 27

dim = int(input())
print(maxVolume(dim))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


L = int(input())

print((L/3)**3)

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

    return edge ** 3


if __name__ == '__main__':
    print(main())

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)**3)

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
v=a*a*a
print(v)

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

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

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

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

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

Solution (Python):

N = int(input())

a = N/3

print(a*a*a)

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    l = int(readline())
    print((l / 3) * (l / 3) * (l - l / 3 * 2))


if __name__ == '__main__':
    solve()

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

Solution (Python):
from decimal import Decimal

L = Decimal(input())

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

Solution (Python):

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

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

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

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

Solution (Python):
import math


l = int(input())

print(math.pow(l/3,3))

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

print((L / 3) ** 3)

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

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

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

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

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

v = pow(l/3, 3)

print(v)

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

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

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

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








print((L/3)**3)

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

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

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

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

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


if __name__ == "__main__":
    main()

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

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

print((l/3)**3)

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

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

a_3 = a/3

print(a_3*a_3*a_3)

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

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

s=L/3

print(s**3)

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

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

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

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

print((n/3)**3)

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

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

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

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

a=N/3

print(a**3)

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

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

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

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

print(L*L*L/27)

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

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

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

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

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

n /= 3

print(n**3)

Solution (Python):



l = int(input())

print((l ** 3) / 27)

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

Solution (Python):


'''

'''

import sys

L = float(input())

x = L / 3

print(x**3)

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

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

import random

print(L**3/27)

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

Solution (Python):
a = float(input())
print((a/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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    n = I()

    return pow(n/3, 3)


print(main())

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

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

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

print((L / 3) ** 3)

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

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

Solution (Python):

"""
Created on Sat Apr  4 19:32:33 2020

@author: Kanaru Sato
"""

l = int(input())

ans= (l**3)/27

print(ans)

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

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

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

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

ap = L /3

print(ap**3)

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

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

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

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
from decimal import *

L = int(input())

d = Decimal(L)

print((d/3) ** 3)

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

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


print(pow(L/3,3))

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

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

Solution (Python):
line = int(input())
calc = line * line * line / 27

print(str(calc))

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

print(l*l*l/27)

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

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

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

V = pow(L, 3) / 27

print('{:.6f}'.format(V))

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

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

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

print('{:.012f}'.format(a ** 3))

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

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

Solution (Python):
value = input()

one = int(value) / 3

print(one **3)

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

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

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

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

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

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

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

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

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

Solution (Python):
import math
L = int(input())
print("{:.12g}".format(math.pow(L/3, 3)))

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

print((l/3)**3)

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

    print(pow(L/3, 3))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

l = ni()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(ans)

Solution (Python):
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

L =int(input())

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

print(float(round(ans, 10)))

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

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

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

Solution (Python):

import sys
L = int(sys.stdin.readline())

print((L/3)**3)

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

print(X**3/27)

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

print((L/3)**3)

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

print ((L/3)**3)

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

print((n/3)**3)

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

print(round(L/3, 6) ** 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 = l / 3;

print(a * a * a);

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

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

print((L/3.0) ** 3)

Solution (Python):

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

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

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

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

Solution (Python):
l = int(input())
x = round(l / 3, 6)
y = round(l / 3, 6)
z = round(l / 3, 6)
print(x * y * z)

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

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

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

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

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

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

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

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

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

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

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

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

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

print(l*l*l)

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def print_list(l): print(*l, sep='\n')
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def No(): print('No')

def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime

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

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

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

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

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

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

Solution (Python):

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

Solution (Python):

x = int(input())
v = (x / 3) ** 3
print(v)

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

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

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

Solution (Python):


L = float(input())

a = L / 3.0

answer = a*a*a

print(answer)

Solution (Python):

"""
Created on Tue Mar 31 00:16:09 2020

@author: black
"""


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

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

x = l / 3
print(format(x**3,'.12f'))

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


ans = 0.0

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

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

Solution (Python):

L = int(input())


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

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

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

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

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

print((L/3)**3)

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

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

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

Solution (Python):
def solve(string):
    return str((int(string) / 3)**3)


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

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

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

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

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

print((L/3)**3)

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

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

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
from decimal import Decimal
 
L = int(input())  
 
deceimal_L = Decimal(L)
 
edge1 = L / 3

 
print(edge1*edge1*edge1)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
from decimal import Decimal

L = int(input())  

deceimal_L = Decimal(L)

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

print(edge1*edge2*edge3)

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

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

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

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

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

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

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 * l/3 * l/3);

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

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

print((l/3)**3)

Solution (Python):
import sys
l=int(sys.stdin.readline())

print((l/3)**3)

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

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

a = L / 3

print(a*a*a)

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

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

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

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