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

-----Sample Output-----
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.

Difficulty: introductory

Starter code:

Solutions:
L = int(input())

ans = (L / 3) ** 3

print(ans)

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

s=int(input())
b=s/3
print(b**3)

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

from math import *
l = int(input())
print((l/3)**3)

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

L = int(input())

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


import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))


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


print(solve())


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

import math
import sys
##### graph implementation with adjacancy list#####
class Graph:
    def __init__(self,Nodes,is_directed=False):
        self.nodes=Nodes
        self.adj_list={}
        self.is_directed=is_directed
 
        for node in self.nodes:
            self.adj_list[node]=[]
            
    def add_edge(self,u,v):
        self.adj_list[u].append(v)
        if self.is_directed==False:
            self.adj_list[v].append(u)
 
    def print_graph(self):
        for node in self.nodes:
            print((node,"->",self.adj_list[node]))
 
    def degree_node(self,node):
        return len(self.adj_list[node])
 
    def dfsUTIL(self,v,visited,parents=[]):
        #print(v,end=" ")
        visited[v]=True
        for i in self.adj_list[v]:
            if visited[i]==False:
                self.dfsUTIL(i,visited,parents)
                parents.append(i)        
    
    def dfs(self,v):
        visited=[False]*(max(self.adj_list)+1)
        parents=[v]
        self.dfsUTIL(v,visited,parents)
        return len(parents)
        
#####sorting a dictionary by the values#####
def dict_sort(ans):
    ans=sorted(list(ans.items()),reverse=True,key=lambda kv:(kv[1]))
    
##### naive method for testing prime or not O(n^.5)#####
def is_prime(n):
    if n==1:
        return 0
    for i in range(2,int(math.sqrt(n))+1):
        if n%i==0:
            return False
    return True

#####swap function#####
def swap(a,b):
    temp=a
    a=b
    b=temp
    return a,b

#####Primes till Nth O(n)#####
def seive_primes(n):
    flag=[0]*(n+10)
    flag[1]=flag[0]=1
    i=2
    while i*i<=n+1:
        if flag[i]==0:
            j=i*i
            while j<=n+1:
                flag[j]=1
                j+=i
        i+=1
    return flag

#####all the prime factors of a number#####
def factors(n):
    d={}
    while(n%2==0):
        if 2 in d:
            d[2]+=1
        else:
            d[2]=1
        n/=2
    for i in range(3,int(n**0.5)+1,2):
        while(n%i==0):
            if i in d:
                d[i]+=1
            else:
                d[i]=1
            n/=i
    n=int(n)
    if n>1:
        d[n]=1
    return d

#####greatest common divisor of two numbers#####
def gcd(a,b):
    if b==0:
        return a
    return gcd(b,a%b)

#####least common multiplyer of two numbers#####
def lcm(a,b):
    return (a*b)//gcd(a,b)

#####function that return all the letters#####
def alphabates():
    return "abcdefghijklmnopqrstuvwxyz"

#####binary search O(logN)#####
def binary_search(ls,n,flag):
    low=0
    hi=n-1
    while(low<=hi):
        mid=(low+hi)//2
        if ls[mid]==flag:
            return mid
        elif ls[mid]>flag:
            hi=mid-1
        else:
            low=mid+1
    return -1

#####quadratic roots#####
def qdrt(a,b,c):
    chk=b*b-4*a*c
    if chk>=0:
        ans1=(-b+chk**0.5)/(2*a)
        ans2=(-b-chk**0.5)/(2*a)
        return [int(ans1),int(ans2)]
    return -1
#####permutations#####
def permutation(n,r):
    if n<r:
        return 0
    ans=1
    for i in range(n-r+1,n+1):
        ans*=i
    return ans

#####combinations#####
def combination(n,r):
    if n<r:
        return 0
    ans=1
    for i in range(r):
        ans*=(n-i)
    div=1
    for i in range(2,r+1):
        div*=i
    return ans//div
        
#####taking an array/list as input#####
def arinp():
    ls=list(map(int,input().split()))
    return ls

#####taking multiple inputs#####
def mult_inp():
    return list(map(int,input().split()))

#####Main function starts from here#####
def main():
    n=int(input())/3
    print((n**3))
def __starting_point():
    main()
    

    
    
    
            
    
    

__starting_point()

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

l=int(input(""))
v=l*l*l
d=int(v/27)
print((v%27)/27+d)

L=float(input())

print((L/3)**3)

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


from decimal import Decimal
l=int(input())
num = Decimal(l/3)
print((num**3))


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

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


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

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

l = int(input())

ans = (l / 3) ** 3

print(ans)


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

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


main()


L = int(input())

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


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

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

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

L = int(input())

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

l = int(input())

print(pow(l/3,3))

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


def __starting_point():
    print(main())
__starting_point()

l = int(input())

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


l = int(input())

x= l/3

ans= x**3

print(ans)

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

l = int(input())
a = l / 3
l = l - a
b = l / 2
c = l - b
print(a * b * c)

n = int(input())

x = n/3
y = n/3
z = (n-x-y)

print(x*y*z)

# import math
# import statistics
# import itertools
a=int(input())
# b=input()
# c=[]
# for i in a:
#     c.append(int(i))
# N,S,T= map(int,input().split())
# f = list(map(int,input().split()))
# g = [int(input()) for _ in range(N)]
# h = []
# for i in range(a):
#     h.append(list(map(int,input().split())))
# a = [[0] for _ in range(H)]#nizigen

print((a/3)**3)

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

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

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

a = int(input())

b = a/3

sub = b**3

print(sub)

L = int(input())
x = L / 3.0
z = L - 2.0 * x
print((x * x * z))


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

l = int(input())
e = l/3
print("{:.10}".format(e**3))

l = int(input())

print((l/3)**3)

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

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

L= int(input())

print ((L/3)**3)

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

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

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

l = int(input())

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


import os, sys, re, math

L = int(input())

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


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


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


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


num = int(input())

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

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

L = int(input())

print((L ** 3) / 27)

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

import sys
import math
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
    
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
    
    
def main():
    L = I()
    print(pow(L/3, 3))
def __starting_point():
    main()
__starting_point()

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

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

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

l = int(input())

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

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

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

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

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

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

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

L = int(input())

edge = L/3

print(edge**3)

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

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

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

import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    l = int(input())
    res = pow(l / 3, 3)
    print(res)


def __starting_point():
    resolve()

__starting_point()

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



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

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

k=float(input())
volume=(k/3)*(k/3)*(k/3)
print(volume)

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


def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(map(int, input().split()))
def i_row(N): return [int(input()) for _ in range(N)]
def i_row_list(N): return [list(map(int,input().split())) for _ in range(N)]

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

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

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

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

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

L = int(input())

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

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

# coding=utf-8

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

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

L = int(input())

print((L / 3) ** 3)

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

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

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

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

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

        



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

l = int(input()) / 3
print(('{:.9}'.format(l**3)))


import sys

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

L = int(input())
L = L/3
V=1
for i in range (3):
    V*=L
print (V)
    


def answer(l: int) -> float:
    return pow(l / 3, 3)


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


def __starting_point():
    main()
__starting_point()

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

l = int(input())

ans = l * l * l / 27

print(ans)


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