Go: package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

var sc = bufio.NewScanner(os.Stdin)

//Sliceconvtof ...
func Sliceconvtof() []float64 {
	strs := strings.Split(sc.Text(), " ")

	var flts []float64
	var x int

	for _, s := range strs {
		x, _ = strconv.Atoi(s)
		xf := float64(x)
		flts = append(flts, xf)
	}

	return flts
}

//ThirdRoot .
func ThirdRoot(f float64) float64 {
	xn := f / 2
	var dmt float64

	for {
		dmt = math.Pow(xn, 3) - f
		if math.Abs(dmt) < 0.00001*f {
			break
		}

		xn = xn - (dmt / (3 * math.Pow(xn, 2)))
	}

	return xn
}

func main() {

	for sc.Scan() {
		i := Sliceconvtof()
		if i[0] == -1.0 {
			break
		}
		fmt.Printf("%6f\n", ThirdRoot(i[0]))
	}

}

Python: while True :
    q = int(input())
    if q == -1 :
        break
    
    n = 1
    x = q / 2
    while True :
        if abs(x**3 - q) < (0.00001 * q) :
            break
        x = x - (x**3 - q) / (3 * x**2)
    
    print('{:.6f}'.format(x))

Python: while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    while abs(x**3-q)>=0.00001*q:
        x=x-(x**3-q)/(3*x**2)
    print(f'{x:.6f}')

Python: while True:
    try:
        n=int(input())
        if n==-1:
            break
        x=n/2
        y=n*10**-5
        while abs(x**3-n)>=y:
            x = (2 * x ** 3 + n) / (3 * x ** 2)
        print(f'{x:.6f}')
    except EOFError:
        break

Python: while 1:
    q=float(input())
    if q<1:
        break
    xn=q/2
    while 1:
        xn=xn-(((xn*xn*xn)-q)/(3*(xn**2)))
        if abs((xn*xn*xn)-q)<0.00001*q:
            print(format(xn,'.6f'))
            break

Python: value = []
i = 1
while True:
	z = int(input())
	if z == -1: break
	value.append(z)
for x in range(1,len(value)+1):
	li = []
	i = 1
	li.append(value[x-1] / 2)
	while True:
		li.append(li[i-1] - ((li[i-1]**3 - value[x-1]) / (3 * li[i-1]**2)))
		if abs(li[i]**3 - value[x-1]) < 0.00001*value[x-1]:
			break
		i += 1
	print(min(li))

Python: while True:
    q = int(input())
    
    if q == -1:
        break
    
    x = q / 2

    while abs(x ** 3 - q) >= q * 0.00001:
        x = (2 * x ** 3 + q) / (3 * x ** 2)
    print("{:.6f}".format(x))

Python: def tri(q):
    x = q/2
    while(abs(x**3-q) >= 0.00001*q):
        x = x - (x**3-q)/(3*x**2)
    return x

while(1):
    n = int(input())
    if n == -1:
        break
    print("{:.6f}".format(tri(n)))

Python: def rec(x1,q):
    return x1-((x1**3-q)/(3*(x1**2)))

q = []
while True:
    try:
        tmp = int(input())
        if tmp == -1:
            break
        q.append(tmp)
    except EOFError:
        break
for i in range(len(q)):
    x1 = float(q[i]/2)
    while True:
        x1 = rec(x1,q[i])
        if abs(x1**3 - q[i]) < 0.00001*q[i]:
            break
    print(x1)

Python: while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    a=0.00001*q
    while abs(x**3-q)>=a:
        b=x**3-q
        c=3*x**2
        x-=b/c
    print(f'{x:6f}')

Python: # coding: utf-8
# Your code here!

while True:
   q = int(input())
   if q == -1: break
   
   x = q / 2
   while abs(x ** 3 - q) >= 0.00001 * q:
      x = x - (x ** 3 - q) / (3 * x ** 2)
   print(x)

Python: #84 三乗根

while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    while abs(x**3-q)>=0.00001*q:
        x=x-(x**3-q)/(3*x**2)
    print(f'{x:.6f}')

Python: import sys
import math
def three(n,p):
    m=float(n)-((math.pow(n,3)-p)/(3*math.pow(n,2)))
    if((math.fabs((m*m*m)-p))<0.00001*p):
        return m
    else:
        return (three(m,p))
i=0
while i<50:
    q=int(input())
    if(q==-1):
        break
    a=float(q)/2
    three_pow=three(a,q)
    print(str('{:.06f}'.format(three_pow)))

Python: while True :
    q = int(input())
    if q == -1 :
        break
    
    n = 1
    x = q / 2
    while True :
        if abs(x**3 - q) < (0.00001 * q) :
            break
        x = x - (x**3 - q) / (3 * x**2)
    
    print('{:.6f}'.format(x))

Python: while True:
    n=int(input())
    if n==-1:
        break
    a=n/2
    
    while abs(a**3-n)>=0.00001*n:
        a=a-(a**3-n)/(3*a**2)
    print(f'{a:.6f}')

Python: import sys
for e in sys.stdin:print(float(e)**(1/3))


####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
########################################################################################################
####################################################
####################################################
########################################################################################################v
############################################################################################################################################################
####################################################
####################################################
####################################################
########################################################################################################v
vv####################################################

Python: def third_root(q):
    x=q/2.0
    while abs(x**3-q)>=q*10**(-5):
        x=x-(x**3-q)/(3*x**2)
    return x
while 1:
    q=int(raw_input())
    if q==-1:break
    ans=third_root(q)
    print(ans)

Python: # Aizu Problem 0080: Third Root
#
import sys, math, os

# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
    sys.stdin = open("sample-input.txt", "rt")


def third_root(q):
    x = q / 2
    while abs(x**3 - q) > 1e-6:
        x = x - (x**3 - q) / (3 * x**2)
    return x


for line in sys.stdin:
    n = int(line)
    if n == -1:
        break
    print("%.6f" % third_root(n))

Python: while True:
    q = int(input())
    if q == -1:
        break
    x = q / 2
    while abs(pow(x, 3) - q) >= 0.00001 * q:
        x = x - (pow(x, 3) - q) / (3 * pow(x, 2))
    print("{:.6f}".format(x))

Python: def third_root(q):
    x=q/2
    while abs(x**3-q)>=q*10**(-5):
        x=x-(x**3-q)/(3*x**2)
    return x
while 1:
    q=input()
    if q==-1:break
    ans=third_root(q)
    print(ans)

Python: while 1:
    q=float(input())
    if q<0:break
    print(q**(1/3))


####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
####################################################
########################################################################################################
####################################################
####################################################
########################################################################################################v
############################################################################################################################################################
####################################################
####################################################
####################################################
########################################################################################################v
vv####################################################