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

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

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

Solution (Python):
import math

L=int(input())

num=L/3
print('{:.07f}'.format(num**3))

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

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

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

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

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

Solution (Python):
import sys
read = sys.stdin.read
def main():
    l = int(input())
    print((l/3)**3)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

len = l/3
vol = len*len*len

print(vol)

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

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

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

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

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

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

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

ans = 0
for i in range(l * 10 ** 3):
    s = ((l * 10 ** 3 - i) / 2) ** 2
    ans = max(ans, s * i / (10 ** 9))
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())
    num = l / 3
    print(num**3)


if __name__ == "__main__":
    main()

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

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

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

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

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

print((l/3)** 3)

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

L = int(input())

print(actual(L))

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

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

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

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

print((L/3)**3)

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

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

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

ans = (L/3)**3

print(ans)

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

print((l/3)**3)

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

print((L**3)/27)

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

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

print((l/3)**3)

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    print(n**3/27)
    
if __name__ == '__main__':
    do()

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

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

a = float(L/3)
b = float(L/3)
c = float(L / 3)

print(a * b * c)

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

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

ans = float(l ** 3 / 27)

print(ans)

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

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

print(l**3)

Solution (Python):

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

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

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

Solution (Python):
import sys

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

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

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

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

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

Solution (Python):
from decimal import Decimal

L = int(input())

w = Decimal(L / 3)
d = Decimal(L / 3)
h = Decimal(L / 3)

ans = Decimal(w * d * h)

print(ans)

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

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

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

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

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

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

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

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

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

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

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

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

r = L / 3

print(r * r * r)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print((L/3)**3)

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

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

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

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

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

Solution (Python):

import sys


def solve(L: int):
    v = pow(L/3, 3)
    print(v)



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())
ans=(l**3)/27

print(ans)

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

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

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

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

print((L/3)**3)

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

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

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

print((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):
from decimal import Decimal
L = Decimal(str(input()))
a=L/3
print(a**3)

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

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

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
def main():
    l = int(input())
    print('{:.32f}'.format((l * l * l) / 27))


if __name__ == '__main__':
    main()

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

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


import sys
sys.setrecursionlimit(300000)


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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
from decimal import *
getcontext().prec = 28
n = Decimal(input())
print((n/Decimal(3.0))**Decimal(3))

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

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

    print((l/3)**3)


if __name__ == '__main__':
    main()

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

L_3 = L / 3

print(L_3**3)

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

print(L**3/27)

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

print(V)

Solution (Python):
L = int(input())
ans = 0
tmp = L / 3

print(tmp**3)

Solution (Python):
x=int(input())
a,b,c = x/3,x/3,x/3

print(a*b*c)

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

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

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

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

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

print((L/3)**3)

Solution (Python):


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


if __name__ == '__main__':
    L = int(input())
    solve(L)

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

l = int(read())
print((l/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):
import math

l = float(input())/3
print(math.pow(l, 3))

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

x = float(l / 3)

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

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

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

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

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

tmp = L/3

print(tmp*tmp*tmp)

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

print((x / 3) ** 3)

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

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

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

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

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

Solution (Python):
L=int(input())
a=L/3
if L%3==0:
    print((L//3)**3)
else:
    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())
if l%3==0:
    k=l/3
    print(k**3)
else:
    n=l/3
    m=l-2*n
    print(n*n*m)

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

Solution (Python):
n = int(input())
a = n//3
b = n%3

if b == 1:
    print((a+1/3)**3)
elif b==2:
    print((a+2/3)**3)
else:
    print(a**3)

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

print(L**3/27)

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

Solution (Python):
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
import cmath as cma
import copy as cp
import sys
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def barr(n): return [False for _ in range(n)]
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7; EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf

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

Solution (Python):
















def main():

    L = int(input())

    print((L/3)**3)


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):

import sys

sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


sys.setrecursionlimit(10**7)






def run():
    L = int(input())
    print((L/3) ** 3)
if __name__ == "__main__":
    run()

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

print((L / 3) ** 3)

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

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

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

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

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

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

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

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""

from collections import deque
import math
from collections import deque, defaultdict
import sys
sys.setrecursionlimit(10 ** 7)


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



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


def ws(): return sys.stdin.readline().split()


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


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def floor(a, b):
    """floor(a/b) 整数値を返す"""
    c = (a - a % b)/b
    return int(c)


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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

print((L/3)**3)

Solution (Python):
n=int(input())
k=3123432442
print("{:.12f}".format((n/3)**3))

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

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

print((L / 3) ** 3)

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

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

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

Solution (Python):
import math as m

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    L = int(input())
    ans = '{:.010f}'.format(L*L*L/27)
    print(ans)

main()

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

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

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

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

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

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

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

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

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

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

print(res)

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

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

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

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    L = I()
    V = (L/3)**float(3.0)
    print("{:.12f}".format(V))

main()

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

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

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

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

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

ans = (L/3)**3

print(ans)

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

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

print((l/3)**3)

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

Solution (Python):
def main():
    import sys
    input = sys.stdin.buffer.readline
    l = int(input())
    print((l/3)**3)


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
from sys import stdin, setrecursionlimit


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

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

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

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

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

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


if __name__ == "__main__":
    solve()

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

Solution (Python):


def f(len):
  print((len / 3) ** 3)

f(int(input()))

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

print(L*L*L/27)

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

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

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

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

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

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

print((L/3)**3)

Solution (Python):
n=float(input())
v=[0]
print(n/3*n/3*n/3)

Solution (Python):
import sys
from io import StringIO
import unittest


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


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3"""
        output = """1.000000000000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """999"""
        output = """36926037.000000000000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    
    resolve()

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

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

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

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

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

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

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

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

print((L / 3) ** 3)

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

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

Solution (Python):

import sys


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


def main():
    L = int(sys.stdin.readline().strip())  
    print(solve(L))


if __name__ == '__main__':
    main()

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

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

r = n/3
ans=r**3
print(ans)

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

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

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

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

L = int(input())
print(maxVolume(L))

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

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

print((L / 3) ** 3)

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

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

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

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

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

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

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

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

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

L /= 3

print(L**3)

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

print((L / 3) ** 3)

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]





L = ii()

print((L/3)**3)

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

Solution (Python):







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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
    '''
    一つの整数
    '''
    return int(input())
def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))

l = inp()
print((l/3.0)**3)

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

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

n = (s/3)

print(n*n*n)

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

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

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

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

print((L/3)**3)

Solution (Python):





L = int(input())
S_list = []
for y in range(L*10**3):
    y_cal = y / 10**3
    s  = 1/4 * (y_cal**3 - 2*L*y_cal**2 +L**2 * y_cal)
    S_list.append(s)

S_max = max(S_list)
print(S_max)

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

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

length = l / 3
print(pow(length, 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):
L=int(input())
print((L**3)/27)

Solution (Python):
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): 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 LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)

MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**5+10)

from bisect import bisect_left

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

Solution (Python):
l=int(input())
print(str(l*l*l/27)+"\n")

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

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


L = int(read())

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

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

x = l/3

ans = x**3
print(str(ans))

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

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

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

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

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

Solution (Python):
l = int(input())
ll = float(l)
a=0
b=0
c=0

if(ll%3 == 0):
	a=ll/3
	b=ll/3
	c=ll/3
else:
	a=ll/3
	b=a
	c=ll-a-b

    
print(a*b*c)

Solution (Python):



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

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

Solution (Python):

"""
Created on Thu May  7 00:03:02 2020

@author: shinba
"""

L = int(input())

L = L/3

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

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

    print((L/3)**3)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

print(l ** 3)

Solution (Python):
L=int(input())
ans=0
for j in range(1,1000*L+1):
    i=j/1000
    ans=max(ans,i*i*(L-2*i))
print(ans)

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

Solution (Python):


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

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

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

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

Solution (Python):

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

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

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

print((L/3)**3)

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

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

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

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

Solution (Python):

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

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

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

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

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

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

print(l**3/27)

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

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

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