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

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

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

ans = (l/3)**3


print(ans)

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

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

Solution (Python):
import sys
l=int(sys.stdin.readline())
s=l/3
ans=s*s*s
print(ans)

Solution (Python):
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

L = int(read())
print(pow(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=float(input())
l/=3
print(l**3)

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

print((L/3)**3)

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

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

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

Solution (Python):

import sys,os
from collections import defaultdict, deque
from fractions import gcd
from math import ceil, floor
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

    L = II()
    assert((L/3)*3 == L)
    print((L/3)**3)

    

if __name__ == '__main__':
    main()

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

Solution (Python):
"""
NTC here
"""
import sys
inp = sys.stdin.readline


def input(): return inp().strip()


flush = sys.stdout.flush





def iin(): return int(input())


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





def main():
    l = iin()
    a = l/3
    print(pow(a, 3))
main()

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

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

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

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

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    L = int(input())
    print((L / 3) ** 3)

    return 0

if __name__ == "__main__":
    solve()

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

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

    print(L**3 / 27)


if __name__ == "__main__":
    main()

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

if L%3 == 0:
    print((L//3)**3)
else:
    print((L/3)**3)

Solution (Python):
from decimal import *

l = Decimal(input())
h = l/Decimal(3)
ans = h**Decimal(3)
print(ans)

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

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

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


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(L):
    n = L / 3
    return n ** 3


def main():
    L = read_int()
    print(slv(L))


if __name__ == '__main__':
    main()

Solution (Python):
import math
from collections import deque
def main():
    L = int(input())
    L = L/3.0

    print(math.pow(L,3))


if __name__ == "__main__":
    main()

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

Solution (Python):
import unittest


class TestC(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(3), 1.0)

    def test_2(self):
        self.assertEqual(think(999), 36926037.0)


def solve():
    L = read()
    result = think(L)
    write(result)


def read():
    return read_int(1)[0]


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(L):
    edge = L / 3
    return edge ** 3


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

Solution (Python):
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''

gi = lambda : list(map(int,input().split()))
n, = gi()
print((n / 3) ** 3)

Solution (Python):
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



L = I()

print(L**3/27)

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

Solution (Python):

import sys


def solve(L: int):
    print(L*L*L/27)
    return



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

if __name__ == '__main__':
    main()

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

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

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

main()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
from re import split
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
import re

sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


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

Solution (Python):



import sys
sys.setrecursionlimit(10000000)


dxdy=((1,0),(0,1))

def pin(type=int):
    return map(type,input().rstrip().split())

def resolve():
    N,=pin()
    print(pow(N,3)/27)
"""         


"""
"""
お前カッコ閉じるの忘れてるだろ
"""
if __name__=="__main__":resolve()

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

print((L/3)**3)

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

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

print((L/3)**3)

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
import math
import bisect

def solve(n):
    return (n/3) ** 3

def main():
    n = int(input())
    ans = solve(n)
    print('%.12f' % ans)

if __name__ == "__main__":
    main()

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

Solution (Python):

L = int(input())

print(L**3/27)

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

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

def func(H):
    h = H/3.0
    ans = h*h*h
    return ans

print(func(H))

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

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

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

Solution (Python):



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

    print((L/3)**3)




if __name__ == "__main__":
    resolve()

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


if __name__ == '__main__':
    resolve()

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

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

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    L = I()
    l3 = L / 3
    print(l3 ** 3)
    

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

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

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

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

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

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

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

print ((L/3) ** 3)

Solution (Python):

from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    l = ii()
    print((l/3)**3)


main()

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]

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

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

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

    print((L / 3) ** 3)


if __name__ == '__main__':
    main()

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

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    l = ri()
    print((l*l*l)/27)


if __name__ == '__main__':
    main()

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

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

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

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):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
from fractions import gcd
from copy import deepcopy
import math
import queue
import numpy as np

Mod = 1000000007
import sys
sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main(): 
    l = int(input())
    print((l/3)**3)
if __name__ == "__main__":
    main()

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

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

Solution (Python):

import sys


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())
print(l*l*l/27)

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

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

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

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

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

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

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

print ((N/3)**3)

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

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

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

print((l/3)**3)

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

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

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

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

Solution (Python):
L=int(input());print('{:.10g}'.format((L**3)/27))

Solution (Python):

import sys


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


import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    l = ni()
    print("{:.10f}".format((l/3)**3))

if __name__ == "__main__":
    main()

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

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

print(l**3/27)

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

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

Solution (Python):
from math import *

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

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

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

print((L/3)**3)

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

Solution (Python):
L = [int(i) for i in input().split()][0]
print(L/3*L/3*L/3)

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

Solution (Python):
from decimal import *

getcontext().prec = 99


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

    ans = Decimal(L / 3) ** 3

    print(ans)


resolve()

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

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

print((l ** 3) / 27)

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

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

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

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

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

print((L/3)**3)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N = int(input())

print((N / 3) ** 3)

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

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

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

Solution (Python):

from decimal import Decimal, getcontext
getcontext().prec = 1000


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


if __name__ == "__main__":
    solve()

Solution (Python):

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

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

ans = L ** 3 / 3 ** 3

print(ans)

Solution (Python):
l=float(input())
a=l/3
b=l/3
c=l/3
a=a*b*c
print ('%.6f'%a)

Solution (Python):
if __name__ == '__main__':
    from sys import stdin
    input = stdin.readline

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

Solution (Python):

import sys


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

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

Solution (Python):

x = int(input())


print((x/3)**3)

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

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

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


main()

Solution (Python):
from sys import exit, setrecursionlimit
setrecursionlimit(10**6)

def array2D(row, col ,val=0):
    return [[val]*col for i in range(row)]

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

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

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

    return (L / 3) ** 3

print(main())

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

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

print((L/3)**3)

Solution (Python):
from decimal import Decimal as D
s=D(input())
print(s**3/27)

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

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

print((L**3) / 27)

Solution (Python):
def examA():
    N, M = LI()
    ans = N*(N-1)//2 + M*(M-1)//2
    print(ans)
    return

def examB():
    def judge(A):
        
        n = len(A)
        for i in range(n//2):
            if A[i]!=A[n-i-1]:
                return False
        return True
    S = SI()
    N = len(S)
    if not judge(S):
        print("No")
        return
    if judge(S[:(N-1)//2]) and judge(S[(N+1)//2:]):
        print("Yes")
    else:
        print("No")
    return

def examC():
    L = I()
    ans = (L/3)**3
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**6)

if __name__ == '__main__':
    examC()

"""

"""

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

print((L/3)**3)

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

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

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

print((l / 3)**3)

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

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

print(l ** 3 / 27)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline

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

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

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

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

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

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

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

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

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

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

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

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





print((l/3)**3)

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

f = (l/3)**3

print(f)

Solution (Python):
L = int(input())
print('%.20f' % ((L/3)**3))

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

l = int(input())

print((l/3) ** 3)

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

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

ll = l/3

print(ll**3)

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

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

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

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

Solution (Python):

import sys


def solve(L: int):
    x = L / 3
    print(x**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())
print((l*l*l)/27)

Solution (Python):
import sys
import itertools
import bisect
from operator import itemgetter
 
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()
def combi(n, r):
  r = min(r, n-r)
  numer = denom = 1
  for i in range(1, r+1):
    numer = numer * (n+1-i) %mod
    denom = denom * i %mod
  return numer * pow(denom, mod-2, mod) %mod

N = I()
n = N/3

print(n**3)

Solution (Python):
import math

L = float(input())
print('{:.10f}'.format(L ** 3 / 27.0))

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):
import numpy as np
L = int(input())
x = L/3

ans = x**3
print(ans)

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

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

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

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

l = n_in()
print((l/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 sys
input = sys.stdin.buffer.readline
 
def main():
    N = int(input())
    print((N**3)/27)
    
if __name__ == "__main__":
    main()

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

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

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

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

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

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

Solution (Python):
L = input()
print "%.10f"%((L/3.0)**3)

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


if __name__ == '__main__':
    main()

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

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

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

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

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

print((L ** 3) / 27)

Solution (Python):
l = float(input())
print('%.18f' % (l / 3.) ** 3)

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

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


if __name__ == '__main__':
    main()

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

print((L/3)**3)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

L = int(input())
print("{:.20f}".format((L / 3.0) ** 3))

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

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

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

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    n = inp()
    print((n/3)**3)
    
if __name__ == "__main__":
    main()

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

print((L/3) ** 3)

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    n=II()
    print(pow(n/3,3))

main()

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