peterverebics/CodeNet_Python_118 huggingface dataset:
L=int(input())
if L%3==0:
    print((L//3)**3)
elif L%3==1:
    print((L/3)*(L/3)*(L/3+1))
else:
    print((L/3)*(L/3+1)*(L/3+1))
N = int(input())

# print(Decimal(N) // Decimal(3))
print(round(N//3, 12))
l = int(input())
ans = 0
for i in range(l+1):
    for j in range(l-i+1):
        k = l-i-j
        ans = max(ans,i*j*k)
print(ans)
import decimal

L=int(input())

x = L/3
decimal.getcontext().prec = 6
x = decimal.Decimal(L / 3)

V=decimal.Decimal(x*x*x)

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

i=1
list=[]
r=1

if(L==1):
 print("1")
else:
  while(i<L):
    j=0.1
    while(j<L):
      if(r<j*i*(L-i-j)):
        r=j*i*(L-i-j)
      j+=0.1
    i+=1
  print(r)
def maxvolume (s): 

    maxvalue = 0

  

   

    i = 1

    for i in range(s - 1): 

        j = 1

          

        

        for j in range(s): 

              

            

            k = s - i - j 

              

           

            maxvalue = max(maxvalue, i * j * k) 

              

    return maxvalue 

s = 8

print(maxvolume(s))
L=int(input())
print(L)
print('{:.6f}'.format(L**3/27))
l = int(input())
n = l
l = round(l / 3)
print(l*l*(n-l*2))
l = int(input())

m = 0
for i in range(l):
    for j in range(l-i):
        t = i * j * (l-i-j)
        if m < t:
            m = t
print(m)
l=int(input())
ans=[]
for i in range(l//2+1):
    for j in range(l//2+1):
        ans.append(i*j*(l-i-j))
print(max(ans))
l = int(input())

max = 0.0

for x in range(l+1):
    for y in range(l+1-x):
        vol = x * y * (l-x-y)
        if vol > max:
            max = vol

print(max)
n = int(input())
N = n//3
print(N*N*N)
def maxvolume( L ): 
  
 
    length = int(L / 3) 
      
    L -= length 
      

    breadth = L / 2
      
    height = L - breadth 
      
    return int(length * breadth * height) 
      

L = 4
print( maxvolume(L) )
def maxvolume( s ): 
  
    # finding length 
    length = int(s / 3) 
      
    s -= length 
      
    # finding breadth 
    breadth = s / 2
      
    # finding height 
    height = s - breadth 
      
    return int(length * breadth * height) 
      
# Driven Program 
s = 8
print( maxvolume(int(input())) )
l = int(input())
a = 0

for i in range(l):
    a = i*((l-i)/2)*((l-i)/2) if a < i*((l-i)/2)*((l-i)/2) else a

print(float(a))
l = int(input())
a = 0
for i in range(1, l):
    for j in range(1, i + 1):
        k = l - i - j
        a = max(a, i * j * k)
print(a)
L=int(input())
L1=(L//3)
L2=L%3
while L2>=10**-8:
    L1+=(L2/3)
    L2=(L2/3)

print(float(L1**3))
L = int(input())

ans = 0
for x in range(L):
    for y in range(L):
        z = L - (x+y)
        if z > 0:
            ans = max(ans,x*y*z)
print(ans)
N = int(input())

ans = 0
for i in range(N):
    for j in range(N):
        k = N - i - j
        if k>0:
            vol = i * j * k
            ans = max(ans,vol)
        
print(ans)
S = int(input())
a = S//3
b = a * 0.8
c = a * 1.2
ans = a * b * c
ans = ans * (1/0.96)
print("{0:.6f}".format(ans))
L=int(input())

i=1
list=[]
r=1

if(L==1):
 print("1")
else:
  while(i<L):
    j=1
    while(j<L):
      list.append(j*i*(L-i-j))
      j+=1
    i+=1
  print(max(list))
import numpy as np

vol = 0
vol_max = 0
L = int(input())

for i in np.arange(1.0,L,0.1):
    for j in np.arange(1.0,i + 0.1,0.1):
        k = L - i - j
        vol = i*j*k
        if vol > vol_max and k > 0:
            #print("i,j,k", "=", i,j,k,"vol = ",vol,"vol_max = ",vol_max)
            vol_max = vol      

print(vol_max)
import sys
import numpy as np
# input処理を高速化する
input = sys.stdin.readline

L=int(input())

V=0
for x in np.arange(0,L+0.1,0.1):
    for y in np.arange(0,L+0.1-x,0.1):
        z = L-x-y
        V = max(V, x*y*z)
print(V)
l=int(input())
if l==1:
	print("%.18f"%((1/3)**3))
	exit()
if l==2:
	tt=2/3
	print("%.18f"%((tt)**3))
	exit()
a=l/3
b=l/3
c=l/3
temp=l%3
# ans=0 
if temp==0:
	ans=(a*b*c)
	print("%.18f"%(ans))
	exit()
if temp==1:
	a+=(1/3)
	b+=(1/3)
	c+=(1/3)
	ans=a*b*c
	print("%.18f"%(ans))
	exit()
if temp==2:
	tt=2/3
	ans=(a+tt)*(b+tt)*(c+tt)
	print("%.18f"%(ans))
	exit()
import math
l = int(input())
x = math.floor(l/3)

if l%3 == 0:
  ans = x**3
elif l%3 == 1:
  ans = x*x*(x+1)
else:
  ans = x*(x+1)*(x+1)

print(str(ans))
L=int(input())
L1=(L//3)
L2=L%3
while L2>=10**-8:
    L1+=(L2/3)
    L2=(L2/3)

print(L1**3)
l=int(input())
ans=0
for a in range(1,l+1):
  b=(l-a)/2
  c=(l-a)/2
  ans=max(ans,a*b*c)
print(ans)
a = int(input())
if a < 3:
	print(0)
else:
	yy = a / 3
	print(yy**3)
def maxvolume (s): 

    maxvalue = 0

  

    # for length 

    i = 1

    for i in range(s - 1): 

        j = 1

          

        # for breadth 

        for j in range(s): 

              

            # for height 

            k = s - i - j 

              

            # calculating maximum volume. 

            maxvalue = max(maxvalue, i * j * k) 

              

    return maxvalue
import math
n = int(input())
print(math.floor(n / 3) * math.floor(n / 3) * math.ceil(n / 3))
n = int(input())

s = n//3
t = n % 3

if t == 0:
    print(s**3)
if t == 1:
    print((s+1)*s*s)
if t == 2:
    print((s+1)*(s+1)*s)
l = int(input())
l1 = l // 3
l2 = (l - l1) // 2
l3 = l - l1 - l2
print(l1 * l2 * l3)
N = int(input())

a = N //3
b = N//3
print(a*b*(N-a-b))
# abc159 c
L = int(input())
ans = 0
for H in range(L):
    for W in range(L-H):
        ans = max(H * W * (L-H-W), ans)
print(ans)
l = int(input())

ans = -1.0
for i in range(1, l+1):
    for j in range(1, l+1):
        k = l - i - j
        if i + j + k == l and k > 0:
            ans = max(ans, float(i * j * k))

print(ans)
#整数の入力
N = int(input())

a = int(N/3)

print(a*a*a)
l=int(input())
ans=0
sum=0
 
for i in range(l):
 for j in range(l):
   sum=i*j*(l-i-j)
   if ans>sum:
      ans=sum
print(ans)
def main():
    l = int(input())

    print((l//3)**3)

if __name__ == '__main__':
    main()
l = int(input())
l = l / 3
print(int(l**3))
L = int(input())

res = 0
result = 0
for i in range(1,L):
    for j in range(1,L - i):
        l = L - i - j
        res = i * j * l
        result = max(res,result)

print(result)
L = int(input())
ans = 0
for i in range(L):
    for j in range(L):
        if i + j <= L:
            ans = max(ans, i * j * (L - i - j))
print(ans)
L = int(input())
s,a = divmod(L,3)
print((s+a)*s*s)
L=int(input())

if L%3==0:
    print((L/3)**3)
elif L%3==2:
    print((L+1)/3 * (L+1)/3*(L-2)/3)
elif L%3==1:
    print((L+2)/3 * (L-1)/3*(L-1)/3)
L=int(input())
if L%3==0:
    print((L//3)**3)
elif L%3==1:
    print((L//3)*(L//3)*(L//3+1))
else:
    print((L//3)*(L//3+1)*(L//3+1))
L = int(input())

if L%3==0:
  h = L//3
  print(h**3)
elif L%3==1:
  h = L//3
  print(h*h*(h+1))
elif L%3==2:
  h = L//3
  print(h*(h+1)*(h+1))
def maxvolume (s): 
    maxvalue = 0
    i = 1
    for i in range(s - 1): 
        j = 1
        for j in range(s): 
            k = s - i - j 
            maxvalue = max(maxvalue, i * j * k) 
              
    return float(maxvalue) 
      
s = int(input())
print(maxvolume(s))
l = int(input())
a = 0

for i in range(l):
    for j in range(l-i):
        k = l-(i+j)
        #print(i,j,k)
        a = i*j*k if i*j*k > a else a

print(float(a))
L=int(input("Enter L:"))
V=(L*L*L)/27
print(V)
L = int(input())
x = int(L/3)

if L%3 >= 1:
    y = int(L/3) + 1
else:
    y = int(L/3)

if L%3 >= 2:
    h = int(L/3) + 1
else:
    h = int(L/3)

print(x**3)
l = int(input())*10
Ma = 0

for i in range(0, l+1, 1):
    for j in range(0, l-i, 1):
        z = l - (i+j)
        result = z*i*j
        if(result>Ma):
            Ma = result
print(Ma/1000)
#!/usr/bin/env python3
import collections
import itertools as it
import math
import numpy as np

# A = input()
A = int(input())
# A = map(int, input().split())
# A = list(map(int, input().split()))
# A = [int(input()) for i in range(N)]
#
# c = collections.Counter()


print(A//3 * A//3 * (A-(A//3)*2))
from sys import stdin
def main():
    readline=stdin.readline
    L=int(readline())
    print((L//3)**3)
if __name__=="__main__":
    main()
L=int(input())
ans=[]
for i in range(1,1000):
    for j in range(1,1000):
        k=L-(i+j)
        ans.append(i*j*k)
Y=max(ans)
print(f"{Y:.6f}")
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

L = i_i()

ans = 0
for x in range(L):
    for y in range(L):
        z = L - x - y
        if z > 0 and x * y * z > ans:
            ans = x * y * z

print(ans)
n = int(input())
if n % 3 == 2:
    print(n//3 * (n//3+1) * (n//3+1))
else:
    print(n//3 * n//3 * (n//3+n % 3))
L = int(input())
ans = 0

for i in range(0, L*10):
  for j in range(0, L):
    if (i / 10) + (j) < L:
      ans = max(ans, (i / 10) * (j) * (L - (i / 10) - (j)))
      
print(ans)
L=int(input())
ans=0
tmp=0
d=3
for i in range(int(L*d/1.3)):
  for j in range(int((L*d-i)/1.3)):
    tmp=(i/d)*(j/d)*(L-(i/d)-(j/d))
    ans=max(ans,tmp,0)
print(ans)
L=int(input())
ans=0
tmp=0
d=10
L_=int(L**(1/3))
for i in range(max(0,int(L_-10)*d),int(L_+10)*d):
  for j in range(max(0,int(L_-10)*d-i),int(L_+1)*d-i):
    tmp=(i/d)*(j/d)*(L-(i/d)-(j/d))
    ans=max(ans,tmp,0)
print(ans)
def solution():
    l = int(input())
    
    maximum = 0
    for i in range(1, l*100):
        yoko = 0.01 * i
        for j in range(l*100-i):
            tate = 0.01 * j
            calc = tate * yoko * (l - tate - yoko)
            maximum = max(maximum, calc)
    print(maximum)

solution()
L=int(input())
ans=0
tmp=0
d=1
for i in range(L*d):
  for j in range(L*d-i):
    tmp=(i/d)*(j/d)*(L-(i/d)-(j/d))
    ans=max(ans,tmp,0)
print(ans)
L = int(input())

if L > 3:
  print((L**3)/27)
else:
  print(L)
n=float(input())
div=n/3
rem=n-2*div
print(div,rem)
print("{:.6f}".format(div*div*rem))
l=int(input())
if l%3==0:
    k=l/3
    print(k**3)
else:
    n=int(l/3)
    m=l-2*n
    print(n*n*m)
l = int(input())
ans = 0
for h in range(1,l-1):
    for w in range(1,l-h):
        ans = max(ans, h*w*(l-h-w))
print(ans)
L = float(input())
a = round(((L / 3) * 10)) / 10
b = round(((L / 3) * 10)) / 10
c = round(((L / 3) * 10)) / 10
#a += round(L - (a + b + c))
L = round(L - (a+b+c),2)
a += L
print(float(a*b*c))
l = int(input())

def f(x,y):
    z = l-x-y
    if z<1 or z>l:
        print(x,y,z)
        return -1
    return x*y*z

def fp(x,y):
    dx = y*(l-x-y) - x*y
    dy = x*(l-x-y) - x*y
    return dx,dy

x = 1.0
y = 1.0
while True:
    dx,dy = fp(x,y)
    if dx<10**-8 and dy<10**-8:
        print(f(x,y))
        exit()

    x += dx * 10**-4
    y += dy * 10**-4
L=int(input())
ans=[]
for i in range(1,1000):
    for j in range(1,1000):
        k=L-(i+j)
        ans.append(i*j*k)
print(max(ans))
L = int(input())
S = L / 3
print(S*S*S+L%3)
L = int(input())

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

elif L % 3 == 1:
    K = L // 3
    print(K ** 2 * (K + 1))

else:
    K = L // 3
    print(K * (K + 1) ** 2)
L = int(input())
V = [float(0)]*10000
for x in range(1,10000):
    V[x] = (x*0.1)**2 *(L-2*(x*0.1))
print(max(V))
n=int(input())
s=n//3
if n%3==1:print(s*s*(s+1))
elif n%3==2:print(s*(s+1)*(s+1))
else:print(s**3)
import numpy as np

l = int(input())
max = 0.0
for x in range(l):
	for y in np.arange(0, l, 0.5):
			v = x * y * (l - x - y)
			if v > max:
				max = v
print(max)
L=int(input())
if L%3==0:
  n=(L//3)**3
elif L%3==1:
  k=L//3
  l=L//3
  m=(L//3)+1
  n=k*l*m
else:
  k=L//3
  l=(L//3)+1
  m=(L//3)+1
  n=k*l*m
print(n)
L=int(input())
x=L/3
l=x-1
h=x+1
v=l*x*h
print(v)
l = int(input())

max = 0
for i in range(1,l):
    for j in range(1,l):
        if(l-i-j <= 0):
            break
        calc = (l - i - j)*i*j
        if(max < calc):
            max = calc


print(max)
L = int(input())

print(format((L*3/27),'.20f'))
s = input()
f = s[:int((len(s)-1)/2)]
print('Yes' if s==s[::-1] and f == f[::-1] else 'No')
l = int(input())

v_max = 0
for width in range(1, l+1):
    for length in range(1, l-width+1):
        height = l - width - length
        v = width * height * length
        if v_max < v:
            v_max = v

print(v_max)
L = int(input(''))
x = 0
y = 0
if(L%3 == 1):
  x = 1
  y = 0
elif (L%3 == 2):
  x = 1
  y = 1
else:
  x = 0
  y = 0
  
print(float((L//3*(L//3+x)*(L//3+y))))
L = int(input())
ans = 0

if(L%3==0):
    ans = (L//3)**3
else:
    if(L%3==2):
        ans = (L//3)*(L//3+1)**2
    else:
        ans = (L//3+1)*(L//3)**2
print(ans)
l = int(input())
ans = 0
for i in range(1, l):
  for j in range(i, l-i):
    ans = max(ans, i*j*(l-i-j))

    #print(i, j, l-i-j)
print(ans)
l = int(input())
s = l // 3
print(s ** 3)
S = int(input())
a = S//3
b = a * 0.8
c = a * 1.2
ans = a * b * c
ans = ans * (1/0.96)
print("{0:.12f}".format(ans))
S = int(input())
a = S//3
b = a * 0.8
c = a * 1.2
ans = a * b * c
ans = ans ** 3/27
print("{0:.12f}".format(ans))
L = int(input())

import random

vol_max = 0

for i in range(1000000):
    a = random.uniform(0, L)
    b = random.uniform(0, L-a)
    c= L-a-b
    vol = a*b*c
    if vol_max < vol: vol_max = vol
    else: continue
        
print(vol_max)
L=int(input())

i=1
list=[]
r=1

if(L==1):
 print("1")
else:
  while(i<L):
    j=1
    while(j<L):
      if(r<j*i*(L-i-j)):
        r=j*i*(L-i-j)
      j+=0.1
    i+=1
  print(r)
L=int(input())
L=L*10
V_new=1
for x in range(1,L+1):
  for y in range(1,L-x):
    V=x*y*(L-x-y)
    if V>V_new:
      V_new=V
print(V_new/10)
from math import sqrt 

  
# function to return maximum volume 

def maxVol(P, A): 

      

    # calculate length 

    l = (P - sqrt(P * P - 24 * A)) / 12

  

    # calculate volume 

    V = l * (A / 2.0 - l * (P / 4.0 - l)) 

  

    

    return V 

  
# Driver code 

if __name__ == '__main__': 

    P = 1000

    A = 16

    print(maxVol(P, A))
l = int(input())
v = 0

for i in range(0,l+1):
    for j in range(0,l-i+1):
       if v < i*j*(l-i-j):
           v = i*j*(l-i-j)

print(v)
L = int(input())
q, mod = divmod(L, 3)

if mod == 0:
    print(q ** 3.0)
L=int(input())

x=round(L/3,3)

print(round(x*x*x,7))
import math
n = int(input())
x = math.floor(n / 3) * math.floor(n / 3) * math.ceil(n / 3)
print(str(x) + "." + '0' * 12)
import sys
input = sys.stdin.readline

def main():
    L = int(input())
    tmp = L//3
    if L%3 == 0:
        print(tmp*tmp*tmp)
    elif L%3 == 1:
        print(tmp*tmp*(tmp+1))
    else:
        print(tmp*(tmp+1)*(tmp+1))


if __name__ == "__main__":
    main()
from decimal import *
N = input()

# print(Decimal(N) // Decimal(3))
print("{0:.15f}".format(Decimal(Decimal(N) // Decimal(3))))
a = int(input())
if a % 3 == 0:
  print((a/3) ** 3)
elif a % 3 == 1:
  print(((a//3) ** 2) * (a//3 + 1))
elif a % 3 == 2:
  print((a//3) * ((a//3 + 1) ** 2))
l=int(input())
a=l%3
if a==1:
    print((l//3)*(l//3)*((l+1)//3)*3)

elif a==2:
     print((l//3)*(l//3)*((l+2)//3)*3)

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

res = 0
result = 0
for i in range(1,L):
    for j in range(1,L-1):
        l = L - i - j
        res = i * j * l
        result = max(res,result)

print(result)
l = int(input())
s = []
for x in range(l):
  for y in range(l - x):
    z = l - x - y
    s.append(x * y * z)
print(max(s))
a = int(input())
if a % 3 == 0:
  print((a/3) ** 3)
elif a % 3 == 1:
  print((a//3) ** 2 * (a//3 + 1))
elif a % 3 == 2:
  print((a//3) * ((a//3 + 1) ** 2))
L = int(input())
l = int(L / 3) 
L -= l
b = L / 2
h = L - b
print(l * b * h)
L = int(input())

a = L // 3
b = (L - a) // 2
c = L - a - b

print(a * b * c)
import sys
import numpy as np
# input処理を高速化する
input = sys.stdin.readline

L=int(input())
div =0.01
V=0
for x in np.arange(div,L+1,div):
    y=x
    z=L-x-y
    V=max(V,x*y*z)

print(V)


# for x in np.arange(1,10+1,0.1):
#     for y in np.arange(1,10+1-x,0.1):
#         print(x,y)
from sys import stdin
L = list(map(int, (stdin.readline().strip().split())))[0]
max=0
for x in range(1,L):
    for y in range(1,L):
        z=L-x-y
        if z<=0:break
        if max<x*y*z:max=x*y*z
print(max)
L=int(input())

if L%3==0:
    a=L/3
    ans=a*a*a
elif L%3==1:
    a=(L+2)/3
    ans=a*(a-1)*(a-1)
elif L%3==2:
    a=(L+1)/3
    ans=a*a*(a-1)

print(ans)
n = int(input())
a = n //3
if n % 3 == 0:
	print( a * a *a)
elif n%3 == 0:
	print( a * (a +1) *a)
else:
	print ( a * (a+1) *(a+1))
l = int(input())
_l = l
if _l < 3:
    l *= 10

ans = 0
for i in range(1, l):
    for j in range(1, l-i):
        k = l - (i + j)
        ans = max(ans, i*j*k)

print(ans if _l >= 3 else ans/1000)
import sys
import numpy as np
# input処理を高速化する
input = sys.stdin.readline

L=int(input())
div =0.1
V=0
for x in np.arange(div,L+1,div):
    for y in np.arange(div,L+1-x,div):
        X = x
        Y = y
        Z = L-X-Y
        V = max(V, X*Y*Z)
print(V)


# for x in np.arange(1,10+1,0.1):
#     for y in np.arange(1,10+1-x,0.1):
#         print(x,y)
L = int(input())
max = 0
for x in range(L - 2):
    pre = 0
    x1 = x + 1
    for y in range(L - x1 - 1):
        y1 = y + 1
        z1 = L - x1 - y1
        if pre != 0:
            if x1*y1*z1< pre:break
        if x1*y1*z1 > max: max = x1*y1*z1
        pre = x1*y1*z1
print(max)
L = int(input())

ans = 0
for i in range(1,L-1):
    for j in range(1,L-i):
        ans = max(i*j*(L-i-j), ans)
print(ans)
# A = [list(map(int, input().split())) for _ in range(3)]
L = int(input())
# B = [int(input()) for _ in range(n)]
# X = list(map(int, input().split()))
# a, b = map(int, input().split())
# S = input()
if L % 3 == 2:
    print((L/3)*2*(L/3+1))
elif L % 3 == 1:
    print((L/3)*((L/3+1)*2))
else:
    print((L//3)**3)
l=int(input())
ans=0
for i in range(1,l-1):
    for j in range(1,l-i):
        temp=i*j*(l-i-j)
        if ans<temp:
            ans=temp

print(ans)
def main():
  
  l = int(input())
  
  v = 0
  for i in range(1,l-1):
    for j in range(1, l-i):
      k = l - i - j
      v = max(v, i*j*k)
  
  print(v)
		

if __name__=='__main__':
    main()
l=int(input())
a=l%3
if a==1:
    print((l//3)*(l//3)*(l//3+1))

elif a==2:
    print((l//3)*(l//3+1)*(l//3+1))

else :
    print((l//3)**3)
import sys
import numpy as np
# input処理を高速化する
input = sys.stdin.readline

L=int(input())
div =10000
V=0
for x in [i/div for i in range(L+1)]:
    for y in [j/div for j in range(L-int((x*div))+1)]:
        X=(x*div)
        Y=(y*div)
        Z = L-X-Y
        V = max(V, X*Y*Z)
print(V)
L = int(input())

res = 0
result = 0
for i in range(1,L):
    for j in range(1,L):
        l = L - i - j
        res = i * j * l
        result = max(res,result)

print(result)
def maxVolume(L):
    length = int(L / 3)
    L -= length
    breadth = L / 2

    height = L - breadth

    print(length * breadth * height)


L = int(input())
maxVolume(L)
l = int(input())
syo = l % 3
v = 0
from decimal import Decimal
l_3sq = Decimal(l /3)
print(l_3sq)

if syo == 0:
    v = (l//3)**3
    print(v)
else:
    v = (l_3sq)**3
    print(v)
l=int(input())

result = 0
for x in range(1,l+1):
  for y in range(x,l+1):
    z = l - (x+y)
    if z < 0:
      break
    v = x*y*z
    result = max(v, result)
print(result)
L=int(input())
ans=0
for i in range(1,L+1):
    for j in range(1,L+1):
        k=L-i-j
        ans=max(ans,i*j*k)
print(ans)
import sys

def main():
  input = sys.stdin.readline
  L = int(input())

  xyz  = 0

  for i in range(L*100):
    x = i/100
    for j in range(L*100-i):
      y = j/100
      z = L-x-y
      newxyz = x*y*z
      if xyz < newxyz:
        xyz=newxyz
  
  print (xyz)


if __name__ == '__main__':
  main()
l = int(input())
maxVol = 0
for i in range(l):
    for j in range(l - i):
        ans = i * j * l - (i**2)*j - i * (j**2)
        if ans >= maxVol:
            maxVol = ans
        else:
            pass
print(float(maxVol))
def maxvolume(s):  
    length = int(s / 3) 
    s -= length 
    breadth = s / 2
    height = s - breadth 
      
    return "{:.12f}".format(length * breadth * height) 
s = int(input())
print(maxvolume(s))
def c():
    L = int(input())
    if (L % 3 == 0):
        a, b, c = (L/3, L/3, L/3)
    elif (L % 3 == 1):
        a, b, c = (L/3, L/3, L/3 + 1)
    else:
        a, b, c = (L/3, L/3 + 1, L/3 + 1)

    print(a * b * c)


##########
if __name__ == "__main__":
    c()
import scipy.optimize as optimize


def main():
    L = float(input())
    def fun(x): return -x[0] * x[1] * x[2]
    cons = ({'type': 'eq', 'fun': lambda x: x[0] + x[1] + x[2] - L})
    bnds = ((0, None), (0, None), (0, None))
    res = optimize.minimize(fun, (0, 0, 0), bounds=bnds,
                            constraints=cons, tol=1e-8)
    print("{:.18f}".format(-res.fun))


main()
# input
L = int(input())

if L==1:
    print(1/27)
elif L==2:
    print(8/27)
else:
    if L%3==0:
        c = L / 3
        print(c*c*c)
    elif L%3==1:
        c = L // 3
        d = c + 1
        print(c*c*d)
    else:
        c = L // 3
        d = c + 1
        print(c*d*d)
l=int(input())
L=10**3
ans=0
for a in range(1,L+1):
    for b in range(1,L-a):
        h=l-a-b
        v=a*b*h
        ans=max(ans,v)
print(ans)
import numpy as np
ans_raw = []
L = int(input())

for i in np.arange(0.1, L/2, 0.1):
    for k in np.arange(0.1, L/2 , 0.1):
        ans = i * k * (L - i - k)
        ans_raw.append(ans)

print(max(ans_raw))
L = int(input())
ans = 0
for i in range(1, L):
    for j in range(1, L):
        k = L - i - j
        ans = max(ans, i * j * k)
print(ans)
L = int(input())

ans = 0
for t in range(L+1):
    ans = max(ans,(L-t)/2 * (L-t)/2 * t)
print(ans)
l=int(input())
vol=0
for i in range(1,l-1):
    for j in range(1,l-i):
        k=l-i-j
        if i+j+k==l:
            if i*j*k>vol:
                vol=i*j*k
print(vol)
L = int(input())
k = 0
val = 0
for i in range(L) :
    for j in range(L-i) :
        k = L - i - j
        val = max(i*j*k,val)

print(val)
l = int(input())

ans=0
for x in range(1,l):
    for y in range(1, l-x):
        z = l-(x+y)
        ans = max(ans, x*y*z)
print(ans)
l=int(input())
if(l>0 and l<=1000):
    a = l // 3
    v = a * a * a
    print('%.12f' % v)
l = int(input())

ans = 0
for i in range(1, l+1):
  for j in range(1, l):
    taiseki = i * j * (l-i-j)
    ans = max(ans, taiseki)

print(ans)
def main():
    L = int(input())
    """
    a + b + c = L 
    a * b * c = (L - b - c) * b * c 
    """
    ans = 0
    for b in range(1,L,1):
        for c in range(1,L - b,1):
            if ans < (L - b - c) * b * c :
                ans = (L - b - c) * b * c
    print(ans)

if __name__ == '__main__':
    main()
def solution():
    l = int(input())
    
    maximum = 0
    for i in range(1, l):
        for j in range(l-i):
            calc = i * j * (l - i - j)
            maximum = max(maximum, calc)
    print(maximum)

solution()
L = int(input())
ans = 0

L1 = L//3
L -= L1
L2 = L//2
L -= L2
print(L1*L2*L)
x = int(input())

num = x // 3
rem = x % 3

if rem == 1:
    res = (num+1)*(num**2)

elif rem == 2:
    res = ((num + 1) ** 2) * num

else:
    res = num ** 3

print(res)
l = int(input())

max_value = -1
for a in range(1, l):
  for b in range(1, l - a + 1):
    c = l - a - b
    max_value = max(max_value, a * b * c)
    
print(max_value)
N = float(input())
a=b=c=N//3
print(a*b*c)
L = int(input())

res = 0
for a in range(1, L + 1):
    for b in range(1, L + 1):
        c = L - (a + b)
        if c <= 0:
            continue
        res = max(res, a * b * c)
print(res)
# ABC159_C
l=int(input())
ans=0
for x in range(1,1001):
    for y in range(1,1001):
        z=l-x-y
        if z>0:
            v=x*y*z
            ans=max(v,ans)
print(ans)
L = int(input())

ans = 0

for i in range(1, L-1):
    for j in range(1, L-i):
        V = 0
        V = i*j*(L-i-j)
        ans = max(ans, V)

print(ans)
l = int(input())
print(((l//3)**2)*(l/3))
def maxvolume( s ): 
    length = int(s / 3)       
    s -= length  
    breadth = s / 2
    height = s - breadth 
    return float(length * breadth * height) 
      
s = int(input())
print( maxvolume(s) )
def main():
    s=float(input())
    mod=s%3
    news=s-mod
    each=news//3
    l=b=h=each
    if mod==1:
        l+=mod
    elif mod ==2:
        l+=mod/2
        b+=mod/2
    vol=l*b*h
    print(vol)
main()
L=int(input())
ans=[]
for i in range(1,1000):
    for j in range(1,1000):
        k=L-(i+j)
        ans.append(i*j*k)
Y=max(ans)
print(f"{Y:.12f}")
l = int(input())
d = l / 3
e = l // 3
if l / 3 == 0:
  print(d ^ 3)
elif l / 3 == 1:
  print(e ^ 2 * (e + 1))
else:
  print(e * (e + 1) * (e + 1))