import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
from io import BytesIO, IOBase
from bisect import bisect_left as bl
from bisect import bisect_right as br 
#########################
# imgur.com/Pkt7iIf.png #
#########################

def sieve(n):
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r
 
def divs(n, start=1):
    divisors = []
    for i in range(start, int(math.sqrt(n) + 1)):
        if n % i == 0:
            if n / i == i:
                divisors.append(i)
            else:
                divisors.extend([i, n // i])
    return divisors
 
def divn(n, primes):
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t

def flin(d, x, default=-1):
    left = right = -1
    for i in range(len(d)):
        if d[i] == x:
            if left == -1: left = i
            right = i
    if left == -1:
        return (default, default)
    else:
        return (left, right)

def modpow(b,p,m):
    res=1
    b=b%m
    while(p):
        if p&1:
            res=(res*b)%m
        b=(b*b)%m
        p>>=1
    return res

def mod_inv(a,m):
    return modpow(a,m-2,m)

def ncr(n,r,m):
    res=1
    if r==0:
        return 1
    if n-r<r:
        r=n-r
    p,k=1,1
    while(r):
        res=((res%m)*(((n%m)*mod_inv(r,m))%m))%m
        n-=1
        r-=1
    return res

def ncrlis(n,r,m,fact):
    return (fact[n]*(mod_inv(fact[r],m)*mod_inv(fact[n-r],m))%m)%m

def dfs(u,lis):
    vis[u]=True
    lis.append(u)
    for v in g[u]:
        if not vis[v]:
            lis=dfs(v,lis)
    return lis
def dfsutil():
    cnc=[]
    for i in range(1,n+1):
        if not vis[i]:
            tmp=[]
            cnc.append(dfs(i,tmp))
    return cnc

def bfs(s,prev):
    q=deque()
    q.append(s)
    vis[s]=True
    while q:
        u=q.popleft()
        for v in g[u]:
            if not vis[v]:
                q.append(v)
                vis[v]=True
                #lvl[v]=lvl[u]+1
                prev[v]=u
def path(s,e):
    prev=[False for i in range(n+1)]
    bfs(s,prev)
    at=e
    res=[]
    while at!=False:
        res.append(at)
        at=prev[at]
    res.reverse()
    if res[0]==s:
        return res
    else:
        return []


def ceil(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def ddd(): return collections.defaultdict(collections.defaultdict(int))
 
 
# region fastio
 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
	newlines = 0
 
	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None
 
	def read(self):
			while True:
					b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
					if not b:
							break
					ptr = self.buffer.tell()
					self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
			self.newlines = 0
			return self.buffer.read()
 
	def readline(self):
			while self.newlines == 0:
					b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
					self.newlines = b.count(b"\n") + (not b)
					ptr = self.buffer.tell()
					self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
			self.newlines -= 1
			return self.buffer.readline()
 
	def flush(self):
			if self.writable:
					os.write(self._fd, self.buffer.getvalue())
					self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
	def __init__(self, file):
			self.buffer = FastIO(file)
			self.flush = self.buffer.flush
			self.writable = self.buffer.writable
			self.write = lambda s: self.buffer.write(s.encode("ascii"))
			self.read = lambda: self.buffer.read().decode("ascii")
			self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

'''def isPalindrome(s):
    return s==s[::-1]

for _ in range(ii()):
    s=input()
    n=len(s)
    d=ddl()
    for i in range(n):
        d[s[i]].append(i)
    a=''
    idx=-1
    for i in range(len(s)):
        if s[i]==s[n-1-i]:
            a+=s[i]
        else:
            idx=i
            break
    if idx==-1:
        print(s)
        continue
    idx2,idx3=-1,-1
    ch1,ch2=s[idx],s[n-idx-1]
    f1,f2=False,False
    if len(d[ch1])>1:
        for i in range(1,len(d[ch1])-1):
            if d[ch1][i+1]
    if idx2!=-1:
        f1=isPalindrome(s[idx:idx2+1])
    if idx3!=-1:
        f2=isPalindrome(s[idx3:n-idx])
    l1,l2=idx2-idx+1,n-idx-idx3
    if f1 and f2 and l1>=l2:
        print(a+s[idx:idx2+1]+a[::-1])
    elif f1 and f2 and l1<l2:
        print(a+s[idx3:n-idx]+a[::-1])
    elif f1:
        print(a+s[idx:idx2+1]+a[::-1])
    elif f2:
        print(a+s[idx3:n-idx]+a[::-1])
    else:
        print(a+s[idx]+a[::-1])'''

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

Measured memory_bytes: 41068