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

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

from decimal import *

























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

inf = float('inf')
mod = 1000000007




def main():
	L = inputInt()

	tmp = L / 3

	print(tmp*tmp*tmp)







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

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



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


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

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



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

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

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

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

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

if __name__ == "__main__":
	main()

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

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

Solution (Python):
inp = int(input())
var = float(inp/3)
vol = var**3
print(vol)

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

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

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

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

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

Solution (Python):
import decimal as dec

l = int(input())
ll = dec.Decimal(l/3)
pro = dec.Decimal(ll * ll * ll)
print(pro)

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

print((l/3)**3)

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

Solution (Python):
n = float(input())
s = n/3

print(s*s*s)

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

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

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

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

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

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

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

print((l/3)**3)

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

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
import queue
import copy
import bisect
import heapq


def dfs(s, prev, pre):
  val[s] += Ope[s] + prev
  for i in G[s]:
    if(i == pre):
      continue
    dfs(i, val[s], s)

def bfs(sx, sy, n):
  que = deque([[sy,sx]])
  while que:
    y,x = que.popleft()
    for i,j in D:
      if(x+i<0 or y+j<0 or x+i>W-1 or y+j>H-1):
        continue
      dist = G[y+j][x+i]
      if(G[y+j][x+i] != "X"):
        if(type(G[y+j][x+i]) is str):
          G[y+j][x+i] = G[y][x]+1
          que.append([y+j,x+i])
        elif(dist>G[y][x]+1):
          G[y+j][x+i] = G[y][x]+1
          que.append([y+j,x+i])
        

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








L = int(input())


ans = (L/3)**3







print(ans)

Solution (Python):



from sys import stdin
from decimal import *


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

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


if __name__ == "__main__":
    main()

Solution (Python):
import math
import sys

import numpy as np
from scipy.optimize import minimize


scan = sys.stdin.readline


def main():
    l = int(scan().rstrip())

    v = lambda x: (x[0] ** 2) * x[1] + (x[1] ** 2) * x[0] - l * x[0] * x[1]
    cons = (
        {"type": "ineq", "fun": lambda x: x[0]},
        {"type": "ineq", "fun": lambda x: x[1]},
        {"type": "ineq", "fun": lambda x: l - x[0] - x[1]}
    )

    result = minimize(v, x0=np.array([l/3, l/3]), constraints=cons, method="SLSQP")
    print(-result["fun"])


if __name__ == '__main__':
    main()

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

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

ans = (l / 3) ** 3

print(ans)

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

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

print(format(ans, '.12f'))

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

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

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

print(L**3 / 27)

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

ans=(L/3)**3

print(ans)

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
l = float(input())
print("%0.6f" % ((l*l*l)/float(27)))

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

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

print(x*y*z)

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

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

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

print((l/3)**3)

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

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

d = l / 3

print(d ** 3)

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

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

Solution (Python):
l = int(input())
x = l/3;
print("%.12f" %float(x*x*x))

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

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

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

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

Solution (Python):


l = int(input())

print((l/3) **3)

Solution (Python):

l = int(input())


v = l / 3
w = l / 3
h = l - v - w

ans = v * w * h


print(ans)

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

print((L/3)**3)

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

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

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

Solution (Python):



import math

l = int(input())

e = float(l) / 3

print(e * e * e)

Solution (Python):
import sys, re
import math
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
 
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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7



l = int(input())

side = l / 3
ans = side * side * side

print(ans)

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

l = round(L/3, 8)
print(round(l*l*l, 6))

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

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

print((L/3) ** 3)

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

def round_down6(value):
    value = Decimal(value).quantize(Decimal('0.000001'), rounding=ROUND_DOWN)
    return str(value)

L = float(input())
l = L/3
print(round_down6(l*l*l))

Solution (Python):

import collections
import itertools as it
import math
import numpy as np


A = int(input())







print(A/3 * A/3 * (A-(A/3)*2))

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())
a = l/3
b = (l-a)/2
c = l-(a+b)
print (a*b*c)

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

print(l**3)

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

Solution (Python):

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

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

def max_volume(L):
    return (L/3)**3
    
print(max_volume(L))

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

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

for i in range(0,l+1):
    for j in range(0,l-i+1):
       if v < i*j*(l-i-j):
           v = i*j*(l-i-j)
    
if vr >= v:
    print(vr)
else:
    print(v)

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

print((L/3)**3)

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

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

VM1 = decimal.Decimal(L**3)
VM2 = decimal.Decimal(27)

print('{:.10f}'.format(VM1/VM2))

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

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

Solution (Python):
import math
l = int(input())
i = l
n = math.ceil(l/9) - 1
l = l / 3
if l ** 3 == i:
    n = 0

print(l**3)

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

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

print(L**3)

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

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

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

print(L**3)

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

W=L/3
H=L/3
V=L/3

print(W*H*V)

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

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

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

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

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

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

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    L = int(sys.stdin.buffer.readline().rstrip())
    print(L ** 3 / 27)


if __name__ == '__main__':
    main()

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

n = float(input())
a = n / 3
ans = a*a*a
print(str(ans))

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

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

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

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

Solution (Python):
import math
i=int(input())
print(pow(i,3)/27)

Solution (Python):
x = int(input())
num = x // 3
rem = x % 3
if rem == 1:
    res = (num+1)*(num**2)
elif rem == 2:
    res = ((num + 1) ** 2) * num
else:
    res = num ** 3
res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

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

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

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

Solution (Python):
import math

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

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

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

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

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

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

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

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

print((L/3)**3)

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

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

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

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

    print( (L/3)**3 )


if __name__ == "__main__":
    main()

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

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math

import itertools



import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


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




if __name__ == "__main__":

    main()

Solution (Python):
def main():
    s=float(input())
    l=b=h=s/3
    print(l*b*h)
main()

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

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

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

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

Solution (Python):
from sys import stdin
L = int(stdin.readline().rstrip())

print((L/3)**3)

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

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

Solution (Python):
import math

n = 15  

L = int(input())
a = math.floor(L / 3 * 10 ** n) / (10 ** n)
b = math.floor(((L - a) / 2) * 10 ** n) / (10 ** n)
c = L - a - b

print(a * b * c)

Solution (Python):

str_l = input()
L = int(str_l)

tmp = L / 3.0
V = tmp * tmp * tmp

print(V)

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

if n % 3 == 0:
  x = n //3
elif n % 3 == 1:
  x = n // 3 + 0.33333333333333
else:
  x = n // 3 + 0.66666666666666

v = x ** 3
print(v)

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

print((l/3)**3)

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

num = L // 3
rem = L % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (L/3)**3
if res > res2:
    print(res)
else:
    print(res2)

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

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

print((L/3)**3)

Solution (Python):
from sys import stdin
import math
import fractions

l = int(stdin.readline().rstrip())
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
import math


def solve(L: int):
    
    
    
    
    
    
    
    
    
    
    
    print(pow(L,3)/27.0)
    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())
l1 = l / 3
print(l1**3)

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

num = 0.0
num = l / 3

print(num**3)

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

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

Solution (Python):
from math import floor, ceil
L = int(input())

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):

l = int(input())

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

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

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

print((n / 3) ** 3)

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

Solution (Python):
from collections import defaultdict, deque, Counter
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7


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


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


def inpl_str(): return list(sys.stdin.readline().split())


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

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

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

ret = (l / 3.0) ** 3

print("{}".format(ret))

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

d = L/3

V = d*d*d

print(V)

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

l=L/3

print(l*l*l)

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

ans = (l / 3) ** 3

print(ans)

Solution (Python):
import numpy as np

L = np.float128(input()) / 3

print(np.power(L, 3))

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

Solution (Python):
def fl(x):
    digits = 30
    form = '%.'+str(digits-1)+'e'
    return float((form % x))

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

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

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

ans = x **3
print(ans)

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

v=(L**3)/27

print(v)

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

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

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

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

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

print((L/3)**3)

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

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

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

res2 = (x/3)**3
if res > res2:
    print(res)
else:
    print(res2)

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


if __name__ == '__main__':
    solver()

Solution (Python):

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

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

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

Solution (Python):
from decimal import Decimal

l = int(input())

ls = Decimal(l) / Decimal(3)
print("{:.10f}".format(ls * ls * ls))

Solution (Python):

tot = int(input())

print(tot/3*tot/3*tot/3)

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

print((l / 3) ** 3)

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

Solution (Python):

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

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

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

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

out = s/3 * s/3 * s/3 
print(out)

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

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

result = (L/3)** 3
print("{:.6f}".format(result))

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

Solution (Python):
import math
import fractions

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

    
    return divisors

def ValueToBits(x,digit):
    res = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        res[i]=now%2
        now = now >> 1
    return res

def BitsToValue(arr):
    n = len(arr)
    ans = 0
    for i in range(n):
        ans+= arr[i] * 2**i
    return ans

def ValueToArray10(x, digit):
    ans = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        ans[digit-i-1] = now%10
        now = now //10
    return ans
'''
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n-r] % p

p = 2
N = 10 ** 6 + 2
fact = [1, 1]  
factinv = [1, 1]  
inv = [0, 1]  

for i in range(2, N + 1):
    fact.append((fact[-1] * i) % p)
    inv.append((-inv[p % i] * (p // i)) % p)
    factinv.append((factinv[-1] * inv[-1]) % p)
'''




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

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

Solution (Python):
n=int(input())
side=n/3
print('%.10f' %(side**3))

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


int_val = decimal.Decimal(x / 3)
answer = int_val * int_val * int_val

print(answer)

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

print( N*N*N/27)

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

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

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

print(L**3/27)

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

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

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

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

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

Solution (Python):
s = input()

l = float(s)/3
print( l ** 3 )

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

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

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

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

max = l / 3

print(max ** 3)

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

l_three_mul = l ** 3

l_big = l_three_mul * 10**6


num = (l_big // 27)


num = num / (10**6)

print(num)

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

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

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

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

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

length = L*1000
max_vol=0
for w in range(1,math.ceil((length+1)/3)):
    if max_vol<w*((length-w)/2)**2:
        max_vol = w*((length-w)/2)**2
print(max_vol/1000000000)

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

Solution (Python):


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

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

print('{:.12f}'.format((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 / 27)

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

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

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

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

Solution (Python):

L = int(input())

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

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

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

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

print((L/3)**3)

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

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

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

print((l/3)**3)

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

print(L ** 3 / 27)

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

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

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

Solution (Python):
import sys
def fastio():
    from io import StringIO
    from atexit import register
    global input
    sys.stdin = StringIO(sys.stdin.read())
    input = lambda : sys.stdin.readline().rstrip('\r\n')
    sys.stdout = StringIO()
    register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))

from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

n, = I()
print((n / 3) ** 3)

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

L_div3 = L / 3
L_route3 = L_div3 ** (1/3)
zan = L_div3 - L_route3

hen = L_route3 + zan

print(hen ** 3)

Solution (Python):
import math

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

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

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

    print(r)

if __name__ == '__main__':
    main()

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

Solution (Python):
def maxvolume( s ): 
  
    
    length = (s / 3) 
      
    s -= length 
      
    
    breadth = s / 2
      
    
    height = s - breadth 
      
    return (length * breadth * height) 
l=int(input())
print(maxvolume(l))

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

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

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

print((l/3)**3)

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

Solution (Python):
import math as m
n=int(input())
n=n/3
print("{0:.12f}".format(m.pow(n,3)))

Solution (Python):
L = int(input().split()[0])
ans = (L / 3) ** 3

print(ans)

Solution (Python):

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

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

print((l/3)**3)

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

print(pow(n/3, 3))

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

Solution (Python):
from decimal import Decimal

L=int(input())
l=Decimal(L/3)
print("{:.12f}".format((l)**3))

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

ans = l2**3
print(ans)

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

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

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

Solution (Python):
try:
    while True:
        L = int(input())
        if L == '':
            break
        a = (L/3)**3
        input(a)
except EOFError:
    pass

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

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

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

Solution (Python):
def maxvolume( s ): 
  
    
    length = s / 3 
      
    s -= length 
      
    
    breadth = s / 2
      
    
    height = s - breadth 
      
    return (length * breadth * height) 
      

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

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

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

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

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

inputNum = inputNum / 3

ans = 0.00

ans = inputNum * inputNum * inputNum

print(ans)

Solution (Python):
import math


L = int(input())

value = L/3

volume = pow(value,3)

print(volume)

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

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

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

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

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

print((l/3) ** 3)

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

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

Solution (Python):

import sys
from decimal import *


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



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

if __name__ == '__main__':
    main()

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

x = float(L / 3)

A = x ** 3

print(A)

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

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

V = L ** 3 / 27

print(V)

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

print((L/3)**3)

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

Solution (Python):
l=int(input())
ans_max = (l/3)**3
for a in range(l):
    min = l-a
    max = l
    mid = min + (max - min) // 2
    for i in range(100):
        if ans_max < a * mid * (l - a - mid):
            ans_max = a * mid * (l - a - mid)
        max = mid
print(ans_max)

Solution (Python):


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

    if l % 3:
        a = l / 3
        print(a * a * (l - 2*a))
    else:
        print((l / 3)**3)

if __name__ == '__main__':
    main()

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

if N % 3 == 0:
    ans = (N/3) ** 3
    print(ans)
else:
    ans = (N ** 3) / 27
    print(ans)

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

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

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