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):
def solve():
    L = int(input())
    print(pow(L/3,3))
if __name__ == '__main__':
    solve()

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

Solution (Python):
from decimal import Decimal

l = Decimal(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 os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [input() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [int(input()) for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

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


class PriorityQueue:
    def __init__(self, l=[]):
        self.q = l
        heapq.heapify(self.q)
        return

    def push(self, n):
        heapq.heappush(self.q, n)
        return

    def pop(self):
        return heapq.heappop(self.q)


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
def resolve():
    L = int(input())
    a = L/3.0
    print(a*a*a)

if __name__ == "__main__":
    resolve()

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

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

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

Solution (Python):
if __name__ == "__main__":
    l = int(input())

    ans = (l / 3) ** 3

    print(ans)

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







print((l/3)**3)

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

Solution (Python):
def solve():
    N = int(input())
    return pow(N/3, 3)

print(solve())

Solution (Python):
from decimal import Decimal as d
n=int(input())
print(d(str(n/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())

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 = float (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
l = int(input())
best = 0
for c in range(l * 1000):
    c /= 1000
    best = max(best, c * ((l - c) / 2) ** 2)
print(best)

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


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

Solution (Python):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

L = read_int()[0]

def solve():
    return (pow(L/3, 3))

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

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

Solution (Python):
import itertools
import sys
import math
import numpy as np
from collections import deque
from itertools import combinations
from functools import reduce
from functools import lru_cache
sys.setrecursionlimit(10**9)

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


if __name__ == "__main__":
  main()

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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((L/3)**3)

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

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

e = L / 3

print(e*e*e)

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

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

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

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

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


a = L / 3

print(a * a * a)

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

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

if __name__ == "__main__":
    resolve()

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

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

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

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

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

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

print((n / 3) ** 3)

Solution (Python):
import sys

l = int(sys.stdin.readline().strip())
print (l**3 / 27.0)

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

print((l/3)**3)

Solution (Python):
L = int(input())
l = L / 3.
print('{:.6f}'.format(pow(l, 3)))

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

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

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

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

    print((l/3)**3)


if __name__ == '__main__':
    main()

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

print("%.12f"%s)

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

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

print((l/3)**3)

Solution (Python):

l = int(input())

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

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

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

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

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

print((l/3)**3)

Solution (Python):
import sys

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

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

if __name__ == "__main__":
    ans = main()
    print(ans)

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

print ((n / 3.0)**3)

Solution (Python):
def c_maximum_volume():
    L = int(input())
    return round((L / 3)**3, 10)

print(c_maximum_volume())

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










x = l/3
print(x**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 fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

L = INT()



a = L / 3
bc = L - a
b = bc / 2
c = bc - b
print(a * b * c)

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

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

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

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  l=I()

  a=l/3
  return a**3


print(main())

Solution (Python):
if __name__ == '__main__':

    l = int(input())
    a, b, c = 0, 0, 0

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

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'

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



main()

Solution (Python):
L=int(input())
A=L/3
B=L-(2*A)
ans=A*B*B
print(ans)

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

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


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

Solution (Python):
l = int(input())
print(pow(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=float(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.0)**3)

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

Solution (Python):


import itertools
from math import factorial
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce

sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7


l = float(input())
a1 = a2 = a3 = l / 3
print(a1 * a2 * a3)

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

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

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

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

print((L / 3.0) ** 3)

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

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

Solution (Python):
import sys
import math

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

length = l / 3

print(length ** 3)

Solution (Python):
def read():
    L = float(input())
    return L,

def solve(L):
    a = pow(L / 3, 3)
    return '{:.10f}'.format(a)


if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

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

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

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

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

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

Solution (Python):
inxx = input()
inxx = inxx.split()

x = int(inxx[0])

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

Solution (Python):


L = float(input())

print((L/3.0)**3)

Solution (Python):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
L=int(input())

print((L/3)**3)

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

if n % 3 == 0:
    print((n//3)**3)
else:
    a = n/3
    b = n/3
    c = n - a - b
    print(a * b * c)

Solution (Python):


  

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

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

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

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

L = int(input())

print((L/3)**3)

Solution (Python):
def ans(s):
    length = s / 3

    s -= length

    breadth = s / 2
    height = s - breadth

    return length * breadth * height

l = int(input())

x = ans(l)

print('%.12f' % x)

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

out = (l ** 3) / 27.
print(out)

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

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

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

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

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):
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 

sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input():
    return sys.stdin.readline()[:-1]
def pri(x):
    if type(x) is list:
        print('\n'.join(map(str, x)))
    else:
        print(x)

L = int(input())

res = pow(L, 3)/27

print(res)

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

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

if n % 3 == 0:
    print((n//3)**3)
else:
    a = n/3
    b = n/3
    c = n - a - b
    print(a * b * c)

Solution (Python):
x=int(input())
x=x/3
x=x*x*x
print("%0.9f"%x)

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

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

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

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

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


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


if __name__ == '__main__':
    solve()

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

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

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

Solution (Python):
from decimal import Decimal
L = int(input())
print(Decimal(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):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

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

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

print(l*l*l/27)

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

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(1000000)


INF = int(1e10)

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

def main():
    from builtins import int, map
    L = int(input())
    print("{:.10f}".format((L / 3) ** 3))


if __name__ == '__main__':
    main()

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

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

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

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

x = L/3.0
y = L/3.0
z = L/3.0

print x*y*z

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




print(m*m*m)

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

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

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

Solution (Python):












mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

if __name__=='__main__':
    main()

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

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

print((l ** 3) / 27)

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

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










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

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

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

print((l**3)/27)

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

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

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

L = ni()

print((L**3)/27)

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

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


if __name__ == '__main__':
    main()

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

print(pow(L/3,3))

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

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

import math

L = one_int()

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):
x=int(input())
print(pow(x/3,3))

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

Solution (Python):



def main():
    import sys
    import math
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    

    def dump(*args):
        sys.stderr.write(str(args))
    l = int(input())
    print((l/3)**3)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

L /= 3
print(L**3)

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

print((L ** 3) / 27)

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

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

Solution (Python):

L = int(input())

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

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

Solution (Python):
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class v:
    def __init__(self, f):
        self.f = f
        self.v = None
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n) 


def f(S):
    for s, t in zip(S, S[::-1]):
        if s != t:
            return False
    return True

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

if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
v = float(input())/3

print("%.9lf" % (v**3))

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

l1 = l / 3

print(l1 ** 3)

Solution (Python):

from sys import stdin
import sys
sys.setrecursionlimit(10**8)

def getInputs():
	inputs=[]
	for line in stdin:
		line=line.split()
		inputs.append(line)
	return inputs


def main(inputs):
	L=int(inputs[0][0])
	print(L**3/27)

	

if __name__=="__main__":
	inputs=getInputs()

	main(inputs)

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

    print(a**3)
if __name__=='__main__':
    main()

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

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

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

ll=l*(1/3)

print(ll**3)

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

Solution (Python):
""" My template """




































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

Solution (Python):
import math
n=int(input())
t=n/3
print(math.pow(t,3))

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

print((l/3)**3)

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

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

f = (l/3)**3

print(f)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

L = float(input())

a = L / 3.

ans = a * a * a
print(ans)

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

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

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

Solution (Python):

import sys


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



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(pow(L/3,3))

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


if __name__ == '__main__':
    main()

Solution (Python):









import sys



readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    l = float(input())
    ll = l/3

    print(pow(ll,3))


if __name__ == '__main__':
    main()

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

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

Solution (Python):



def solve(*args: str) -> str:
    l = int(args[0])

    return str((l/3)**3)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

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

print((L / 3) ** 3)

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


if __name__ == "__main__":
    main()

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())
    return (L/3) *(L/3) * (L/3)
if __name__ == '__main__':
    print(main())

Solution (Python):


L = int(input())

print(pow(L/3, 3))

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
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 fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7

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

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

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

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

Solution (Python):
from math import *
l=int(input())
k=3*(log10(l)-log10(3))
print(pow(10,k))

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

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

Solution (Python):
def inpl():
    return list(map(int, input().split()))


L = int(input())

print(L**3 / 27)

Solution (Python):
import sys


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


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

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

Solution (Python):
import sys


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


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

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

ans = n*n*n

print("{:.7f}".format(ans/27))

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

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

tmp = l / 3

print(tmp ** 3)

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