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
sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

def solve():
    l = II()

    print(1 / 27 * l ** 3)


if __name__ == '__main__':
    solve()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
import sys
def I(): return int(input())  
def Is(): return map(int, input().split())  
def LI(): return list(map(int, input().split()))  
def TI(): return tuple(map(int, input().split()))  
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  
def LS(): return list(input())  
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

l = I()
print(l*l*l/27)

Solution (Python):
from decimal import Decimal, ROUND_HALF_UP

l = int(input())

ans = Decimal(str((l/3)**3)).quantize(Decimal('0.0000001'), rounding=ROUND_HALF_UP)

print(ans)

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

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

print((L / 3) ** 3)

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

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

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

V = x * y * z

print(V)

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

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

L = INT()

print(L**3/27)

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

Solution (Python):
import math
import queue
from collections import defaultdict
 
def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def printQueue(q):
	r=q
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)

l = readInt()
a = l/3
print(a*a*a)

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

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

Solution (Python):


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

Solution (Python):
from __future__ import print_function

from functools import reduce
from operator import mul
from collections import Counter
from collections import deque
from itertools import accumulate
from queue import Queue
from queue import PriorityQueue as pq
from heapq import heapreplace
from heapq import heapify
from heapq import heappushpop
from heapq import heappop
from heapq import heappush
import heapq
import time
import random
import bisect
import itertools
import collections
from fractions import Fraction
import fractions
import string
import math
import operator
import functools
import copy
import array
import re
import sys
sys.setrecursionlimit(500000)


input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


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


if __name__ == '__main__':
    main()

Solution (Python):

import sys


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


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

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    
    main()

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

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

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

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

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

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

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

print(round(float((float(l/3))**3),10))

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

Solution (Python):
a=int(input())
print('{:.6f}'.format(a*a*a/27))

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

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

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


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


if __name__ == '__main__':
    main()

Solution (Python):

"""
from sys import stdin
n = int(stdin.readline().rstrip())
data = [stdin.readline().rstrip().split() for _ in range(n)]
print(data)
print(*data, sep='\n')
"""


"""
s =input()
s=list(input())
a=int(input())
x,y = map(int,input().split())	
li = input().split()	
li = list(map(int,input().split()))	
li = input().split('T')	
"""



"""
from sys import stdin
n = int(stdin.readline().rstrip())
data = [stdin.readline().rstrip().split() for _ in range(n)]
print(data)
print(*data, sep='\n')
"""


"""
s =input()
s=list(input())
a=int(input())
x,y = map(int,input().split())	
li = input().split()	
li = list(map(int,input().split()))	
li = input().split('T')	
"""

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

Solution (Python):


import math

L = int(input())

h = L / 3

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6) 
import math
from copy import copy, deepcopy
from operator import itemgetter

from bisect import bisect_left, bisect, bisect_right

from collections import deque 



from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush


def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds




L = int(input())







print((L/3)**3)

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


if __name__ == '__main__':
    main()

Solution (Python):
import math
class abc_159:
    
    def __init__(self):
        pass
    
    def A(self):
        NM=list(map(int,input().split()))
        print(int((NM[0]*(NM[0]-1))/2 + (NM[1]*(NM[1]-1))/2))
    
    def B(self):
        S=input()
        if S==S[::-1] and S[:int((len(S)-1)/2)]==S[:int((len(S)-1)/2):-1] and S[int((len(S)+3)/2)-1:len(S)]==S[int((len(S)+3)/2)-1:len(S)+1][::-1]:print("Yes")
        else:print("No")
        
    def C(self):
        
        
        
        
        L=int(input())
        A,B,C=0,0,0
        
        ans_list=self.f2_ans(3,-4*L,L*L,L)
        
        C = ans_list[0] if self.f3_sum(ans_list[0],L)>=self.f3_sum(ans_list[1],L) else ans_list[1]
        B = (L-C)/2
        A = L-B-C
        print(A*B*C)
            
    
    def f2_ans(self,a,b,c,L):
        ans_list=[]
        
        discrimination=b*b-4*a*c
        kai1=(-b+math.sqrt(discrimination))/(2*a)
        kai2=(-b-math.sqrt(discrimination))/(2*a)
        
        ans_list.append(kai1)
        ans_list.append(kai2)
        
        return ans_list
    
    def f3_sum(self,x,L):
        return (x*x*x)+(-2*L*x*x)+(L*L*x)
        
        
    def D(self):
        pass
    
    def E(self):
        pass
    
    def F(self):
        pass
    
    
if __name__=='__main__':
    obj=abc_159()
    obj.C()

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

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

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

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

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())
x = l / 3

v = x**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())
x = float(l*l*l/27)
print(x)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


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


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

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

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

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

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

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

Solution (Python):


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

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


main()

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

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

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

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

print(l*l*l/27)

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

hen = float(L/3)
volume = float(hen ** 3)
print(volume)

Solution (Python):
import sys

l = int(input())

a = b = c = l/3

v = a*b*c

print(v)

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

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

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

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

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

a = l / 3

print(a**3)

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

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

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

print((l/3)**3)

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

y=l
z=(l-y)/2
x=l-y-z
ans=max(ans,x*y*z)

y=l/3
z=(l-y)/2
x=l-y-z
ans=max(ans,x*y*z)


print(ans)

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

print((l/3)**3)

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

print(N/3*N/3*N/3)

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

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

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

"""
Z = 0

n = 100000
step = n*L
V_array = []

for i in range(step):
    Z += (1/n) * i
    V = (L-2*Z)*Z**2
    V_array.append(V)
    
V_max = max(V_array)
"""

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

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

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

print(format((L**3/27),'.20f'))

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

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

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

Solution (Python):
if __name__ == '__main__':
    L = int(input())
    side = L / 3
    print(side ** 3)

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

 
print(x**2 *(L-2*x))

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

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

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

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

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

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

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

n = l / 3

print(n * n * n)

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

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

print(ans)

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


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

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

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

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

print(n**3/27)

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

a=float(l/3)

v=a**3

print(v)

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

v = (l/3)**3

print(v)

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

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

a = L / 3
b = L / 3
c = L - a - b

print(a*b*c)

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

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

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

print((l/3)**3)

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

print((s/3)**3)

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

Solution (Python):
import sys;input=lambda:sys.stdin.readline().rstrip();aint=lambda:int(input());ints=lambda:list(map(int,input().split()))
import math;floor,ceil=math.floor,math.ceil
from collections import deque
Yes=lambda b:print('Yes')if b else print('No');YES=lambda b:print('YES')if b else print('NO')
is_even=lambda x:True if x%2==0 else False

def main():
  l=aint();print(l**3/27)

if __name__ == '__main__':
  main()

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

print((L/3)**3)

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


if __name__ == '__main__':
    q3()

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

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

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

print((L/3)**3)

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

print((L/3.0)**3)

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

print((L/3) **3)

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

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

Solution (Python):
import sys
import numpy as np

input = sys.stdin.readline

L=int(input())











print((L/3)**3)

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

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

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

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

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

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

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

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

hen = L / 3

print(hen**3)

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

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

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

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

x = (1/3) * L

ans = x**3

print(ans)

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

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

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

a = l/3
v = a*a*a

print(v)

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

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

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

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

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

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

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

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

print(pow(l / 3, 3))

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

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

Solution (Python):


L = int(input())

ans = (L / 3) ** 3

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

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

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

print(l_1**3)

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

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

Solution (Python):
from sys import stdin
import math

L = int(input())

l = L / 3

print(l*l*l)

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

print('{:.09f}'.format((l/3)*(l/3)*(l/3)))

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(L: int):
    print(pow(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())




vol=(l/3)**3

print('{:.9f}'.format(vol))

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

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

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

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

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

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

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

print((l**3)/27)

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


if __name__ == '__main__':
    sol()

Solution (Python):


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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    l = int(rl())
    print((l / 3) ** 3)

    
if __name__ == '__main__':
    solve()

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

print((l/3)**3)

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

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

L = int(input())

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

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

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

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

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

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

Solution (Python):
import math

l = int(input())

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

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


v = 1/27 * l * l * l

print(v)

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

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

Solution (Python):

import math

N = int(input())
print((N /3.0) **3)

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

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

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

a = n * (1 / 3)


print(a ** 3)

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

Solution (Python):
L=float(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(pow(l / 3, 3))

Solution (Python):
from decimal import *
getcontext().prec = 20
l = int(input())
print((Decimal(l) / Decimal(3)) ** 3)

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

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

print((N / 3 )** 3)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
'''
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
for test in range(int(input())):
'''
inf = 100000000000000000  

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

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

Solution (Python):


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

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

print((l/3.0)**3)

Solution (Python):

L = float(input())
one = L / 3
print(one*one*one)

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

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

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

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

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

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

print(x**3/27)

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

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

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

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

print((L/3)**3)

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

c = float(L) / 3
print(c * c * c)

Solution (Python):
def main():
    L = int(input())
    print(L**3/27.0)
if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

print(math.pow(n/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())
V = (l/3)**3
print(V)

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

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

t = round(L/3, 9)
y = round(L/3, 9)
n = round(L/3, 9)

print(t * y * n)

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

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 = 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/3)

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

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

print(ans)

Solution (Python):



L = int(input())

center = (L/3)
pre = center - 0.1

follow = center + 0.1




print(center*center*center)

Solution (Python):
print((int(input())/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())
x = y = z = l/3.000000000
ans = x*y*z
print('{:.12f}'.format(ans))

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

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

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

Solution (Python):
from sys import stdin
import math

if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    L = int(_in[0])  
    
    cnt = (L/3)**3
    
    print(cnt)

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

Solution (Python):
import sys

l = int(sys.stdin.readline().rstrip())

def main():
    print(pow(l / 3, 3))

if __name__ ==  '__main__':
    main()

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

max_abc = L/3

print(max_abc ** 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(pow(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())
max_vol=L**3/27

print(max_vol)

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):
i = int(input())
c = i/3 + 0.0
v = c*c*c
print(v)

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

Solution (Python):


L = int(input())

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

Solution (Python):
from collections import deque, Counter as cnt
from collections import defaultdict as dd
from operator import itemgetter as ig
from bisect import bisect_right as bsr
from math import factorial, ceil, floor
import sys
sys.setrecursionlimit(1000000)


args = None
INF = float("inf")
MOD = int(1e9 + 7)


def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]


def nlist(n, v):
    if not n:
        return [] if type(v) is list else v
    return [nlist(n[1:], v) for _ in range(n[0])]


def yesno(v):
    print(["Yes", "No"][not v])



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


if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

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

Solution (Python):


import sys



















def main():
    mod = 1000000007                  
    inf = float('inf')
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    num = ii()
    print((num / 3) ** 3)

if __name__ == "__main__":
    main()

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

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


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


if __name__ == '__main__':
	main()

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

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

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):

l = int(input())


if (l<1 or l > 1000):
  quit()

length = (l/3)
l = l - length


breadth = (l/2)

l = l - breadth

height = l


maxVolume = length*breadth*height

result = float(l*l*l)
print (maxVolume)

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

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

Solution (Python):

import sys
import collections
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

class Run:
    def build(gv):
        gv.L = int(input())

    def solve(gv):
        side = gv.L / 3
        ans = side**3
        ans = round(ans, 12)
        print(ans)
        
if __name__ == '__main__':
    run = Run()
    run.build()
    run.solve()

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

print(l**3/27)

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

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

res = (L / 3) ** 3

print(res)

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

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

print(n**3/27)

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

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

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

print( (L ** 3) / 27)

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


def main():
    print(pow(L/3,3))


if __name__ == '__main__':
    main()

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

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

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

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

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

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

ans = (l / 3) ** 3;

print(ans);

Solution (Python):
from sys import stdin
L = list(map(int, (stdin.readline().strip().split())))[0]
max=float(L/3)**3
print(max)

Solution (Python):
v = int(input())
'''
ans = 0
for a in range(v+1):
    for b in range(v-a+1):
            if a*b*(v-a-b) > ans:
                ans = a*b*(v-a-b)
print(ans)
'''
print((v/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())
L = 1000 * l
max = 0
V = 0
for a in range(L):
    V = a*((L - a)/2)*(L - a - ((L - a)/2))
    if max <= V:
        max = V
print(max/1000000000)

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

print((L/3)**3)

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

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

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

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

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

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

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

l1 = L / 3.0
print(l1**3)