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
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

l = ni()

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

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

print((l / 3) ** 3)

Solution (Python):


L = int(input())
d = L / 3

print(d**3)

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

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

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

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

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

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

Solution (Python):
import sys
import math

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

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

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

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

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

print((l/3)**3)

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

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

Solution (Python):
from decimal import Decimal as dec
L = int(input())
dL = dec(L)

print((dL/3)**dec(3))

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

print((l/3)**3)

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

Solution (Python):


L = int(input())

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

Solution (Python):
import decimal
decimal.getcontext().prec = 200

l = int(input())
l = decimal.Decimal(l)
s = l / 3
v = s ** 3
print(v)

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

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

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

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

v = (inp/3)**3

print(v)

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

print((l/3)**3)

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

Solution (Python):








import sys
sys.setrecursionlimit(10 ** 5 + 10)


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

resolve()

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

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

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

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

print(ans)

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

ll_tri = ll / 3

volume = ll_tri * ll_tri * ll_tri

print(volume)

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

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

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

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

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

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

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

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

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

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

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

print(V)

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

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

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

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

Solution (Python):

import sys



def solve(L: int):
    a=L/3-1e-10
    print(a**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())







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

Solution (Python):
N = int(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)**3)

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

print(L*L*L/27)

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

Solution (Python):
L=int(input())
from decimal import *
a=Decimal(L/3)
print(a**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):
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
from bisect import bisect, bisect_left, bisect_right

MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()

sys.setrecursionlimit(10 ** 8)

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

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

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

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

L = int(input())

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

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

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

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

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

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


def print_matrix(mat):
    for i in range(len(mat)):
        print(*mat[i])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    L = I()

    
    
    
    


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


if __name__ == '__main__':
    main()

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

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

x = n/3.0

print(x**3)

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

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

Solution (Python):
def inp():
    return input()
def iinp():
    return int(input())
def inps():
    return input().split()
def miinps():
    return map(int,input().split())
def linps():
    return list(input().split())
def lmiinps():
    return list(map(int,input().split()))
def lmiinpsf(n):
    return [list(map(int,input().split()))for _ in range(n)]

l = iinp()
ans = 0

k = (l/3)

ans = k**3

print(ans)

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

n = l/3

print(n**3)

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

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

print(N**3/27)

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

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

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

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

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

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 = input()
l = int(l)

r = (l/3) ** 3

print(r)

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






tmp = l/3

print(tmp**3)

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

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    
    L = [int(x) for x in sys.stdin.readline().split()][0]  
    
    

    
    
    
    

    logger.debug('{}'.format([]))

    print((L / 3)**3)


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


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)

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

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

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

Solution (Python):
from decimal import Decimal
L = Decimal(input())
L3 = L/3
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())
print((L**3)/27)

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

main()

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

l = L/3

print(l**3)

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

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

print(pow(l, 3))

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

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]

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

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

Solution (Python):
if __name__ == '__main__':
    
    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):



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

if __name__=='__main__':
  main()

Solution (Python):

total_length = float(input())
single_length = total_length/3
volume = single_length**3
print(volume)

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

print(l**3/27)

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

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

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

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

a=L/3

print(a**3)

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

S = (L/3.0)**3

print(S)

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

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

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

print((l/3)**3)

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(L: int):
    
    
    
    
    
    
    
    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().strip())
print( (L/3)**3 )

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

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

print(ans)

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

Solution (Python):

l = int(input())

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

Solution (Python):
num_inp = int(input())
dummy = num_inp / 3
amari = num_inp - dummy * 3
ans = dummy ** 2 * (dummy + amari)
print(ans)

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

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

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

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

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

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

    print(l*l*l)

main()

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

print((l/3)**3)

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

Solution (Python):
n  = [list(map(int, s.split())) for s in open(0)][0][0]
c = n / 3
print(c ** 3)

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

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

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

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

K = L / 3

print(K ** 3)

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

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

print((L / 3) ** 3)

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

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

d = l/3.0

print(d*d*d)

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

ans = m ** 3
print(ans)

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

Solution (Python):

L = int(input())

print((L / 3) ** 3)

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

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

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

result = (L / 3.0) ** 3

print(result)

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

print((l/3)**3)

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

Solution (Python):
from decimal import Decimal

L = int(input())

hen = Decimal(L / 3)

print(hen ** 3)

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

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

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

n = L / 3.0

print(n**3)

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

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

Solution (Python):
import sys
import math
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
import itertools
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
x = y = z = N / 3
print(x * y * z)

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

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

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

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

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

a = l/3
b = l - 2 * a

print(a*a*b)

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

print((L / 3) ** 3)

Solution (Python):
def main():
    L = int(input())
    x = pow((L/3), 3)
    return x
print(main())

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

print((L/3)**3)

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

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

print((L/3)**3)

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

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

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

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

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

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

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

print((l/3)**3)

Solution (Python):
import sys
import math
from functools import reduce
from operator import mul
sys.setrecursionlimit(10**6)

def InMap(): return list(map(int, sys.stdin.readline().split(' ')))
def In(): return int(sys.stdin.readline())
def InS(): return sys.stdin.readline()

L = In()
vol = L*L*L
print(vol/27)

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

Solution (Python):


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

if __name__ == "__main__":
    main()

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect
import heapq


MOD = 1000000007


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


def lcm(a, b):
    return a * b // gcd(a, b)


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def is_prime(n):
    if n == 1:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def main():
    L = get_input(int)

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


if __name__ == '__main__':
    main()

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())
ans = 1
for i in range(3):
  ans = ans *(l/3)
print(ans)

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

a,b,c = l/3,l/3,l/3

print(a*b*c)

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

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

ans = L**3 / 27

print(ans)

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

an=l/3

print(an*an*an)

Solution (Python):

import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from heapq import heappop,heappush
import time
import os
import sys
import datetime
from functools import lru_cache
readline=readline = sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def fac_list(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s



def f():
    return 1

L=int(input())
R=[]
print((L/3)**3)

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

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

Solution (Python):
from decimal import *

L = int(input())
a = Decimal(str(L)) / Decimal("3")
print(a * a * a)

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

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

Solution (Python):
import sys 
input = sys.stdin.readline
MOD = 10**9 +7
INF = 10**9
from bisect import bisect_right

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


if __name__=='__main__':
    main()

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

L = int(input())

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

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

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

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

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
ZIP = lambda: zip(*(MAP() for _ in range(n)))

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


def main():
   L = INT()
   print((L/3) ** 3)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate
    
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    

    
    

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





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

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

print((L/3)**3)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

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

if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal

L = Decimal(int(input()))

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

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

Solution (Python):
from sys import stdin
def main():
    readline=stdin.readline
    L=int(readline())
    print((L/3)**3)
if __name__=="__main__":
    main()

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

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

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    L = ir()
    print((L/3)**3)
resolve()

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

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

Solution (Python):





def solv(L):
    e = L / 3.0
    return e*e*e


if __name__ == "__main__":

    L = int(input())
    ans = solv(L)

    print(ans)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()

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

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

Solution (Python):


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


submit()

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

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


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):
import fractions
L = int(input())
a = fractions.Fraction(L, 3)
ans = float(a ** 3)
print(ans)

Solution (Python):
import sys,math,copy,queue,itertools
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
def LI(): return [int(x) for x in input().split()]
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(0,1),(-1,0),(0,-1))
L = int(input())
ans = (L/3) ** 3
print (ans)

Solution (Python):
import sys
import math
import collections
from collections import deque
l = int(input())




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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def solve():
    l = II()
    print((l / 3) ** 3)
    return



if __name__ == '__main__':
    solve()

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

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

print(l**3/27)

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

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

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

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

print((L / 3) ** 3)

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

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

ans = (L/3)**3

print(ans)

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