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]))
	}

}

C++: #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <fstream>
#include <complex>
#include <stack>
#include <queue>

using namespace std;
typedef long long LL;
typedef pair<int, int> P;
static const double EPS = 1e-5;

#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
double f(double x,double q){
  return (x-(x*x*x-q)/(3*x*x));
}
double newton(double x,double q){
  double nx = f(x,q);
  if(abs(nx*nx*nx-q)<0.00001*q) return nx;
  else return (newton(nx,q));
}
int main(void){
  int q;
  while(cin>>q){
    if(q==-1) break;
    printf("%lf\n",newton(q/2,q));
  }
  return 0;
}

C++: #include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

int main()
{
  long long x;
  while (1){
    cin >> x;
    if (x < 0){
      break;
    }
    printf("%.5f\n", cbrt(x));
}
  return 0;
}

C++: #include <iostream>
#include <cmath>
using namespace std;
#define EPS 0.00001

//0080
int main(){
	// x^3=qを漸化式でとく
	// X(n+1) = X(n)-( X(n)^3 - q )/( 3*(X(n)^2) )

	int q;
	while(cin >> q, q!=-1){
		double x = (double)q/2.0;
		while(1){
			double c = (x*x*x-q);
			x = x-c/(3*x*x);
			
			if(abs(c) < q*EPS){
				cout.setf(ios::fixed);
				cout.precision(6);
				cout << x << endl;
				break;
			}
		}
	
	}
}

C++: #include <iostream>
#include <cmath>
using namespace std;

double x, q, n;

int hantei(double x, double q){
	double z = 0.00001 * q;
	double zz = pow(x, 3) - q;
	if (z > fabs(zz)) { return 0; }
	else { return 1; }
}

double zen(double x, double q){
	double ans = x - (pow(x, 3) - q) / 3 / pow(x, 2);
	return ans;
}

int main(){
	while(cin >> q){
		if (q == -1) { break; }
		x = zen(q / 2, q);
		n = hantei(x, q);
		while(n != 0){
			x = zen(x, q);
			n = hantei(x, q);
		}
		cout << x << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <cmath>
#include <cstdio>
const double eps = 0.00001;
using namespace std;

int main(void) {
    int q;
    while (1) {
        cin >> q;
        if (q == -1) break;

        double bx = q/2.0;
        do {
            double ax = bx - (bx*bx*bx - q)/(3*bx*bx);
            bx = ax;
        } while (abs(bx*bx*bx-q) >= eps*q);
        printf("%.7f\n", bx);
    }

    return 0;
}

C++: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <complex>
#include <fstream>
#include <iomanip>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }

int main()
{
	double q;
	while(cin >> q && q + 1)
		cout << setprecision(10) << pow(q, 1.0 / 3.0) << endl;
}

C++: #include <cstdio>
#include <math.h>
using namespace std;

int q;
double x, x3, e;

int main(){
	while (scanf("%d", &q), q != -1) {
		e = 0.00001*q;
		x = q / 2.0;
		x3 = pow(x, 3);
		while (!(x3 - q < e && x3 - q > -e)) {
			x = x - (x3 - q) / (3 * pow(x, 2));
			x3 = pow(x, 3);
		}
		printf("%.6f\n", x);
	}


	return 0;
}

C++: #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;

//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c) for(auto it=(c).begin();it!=(c).end();it++)
#define all(c) c.begin(),c.end()
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
const double EPS = 1e-10;

signed main() {
	double q;
	while (cin >> q, q != -1) {
		double x = q / 2;
		while (abs(x*x*x - q) >= (0.00000001)*q) {
			x = (x - ((x*x*x - q) / (3 * x*x)));
		}
		cout << x << endl;
	}
	return 0;
}

C++: #include <cstdio>
#include <cmath>
using namespace std;

void solve(long long q) {
    long double x = q / 2.0;
    while(abs(x*x*x-q) >= 0.000001*q) {
        x = 1.0 * x - (x*x*x - q) / (3 * x*x);
    }
    printf("%.15Lf\n", x);
}

int main() {
    long long q;
    while(~scanf("%lld",&q) && ~q) solve(q);
}

C++: #include <iostream>
#include <iomanip>
#include <cmath>

int main(){
    int q;
    double x;
    std::cout << std::setprecision(6) << std::fixed;
    while(1){
        std::cin >> q;
        if(q == -1){
            return 0;
        }
        x = q / 2.0;
        while(std::abs(x * x * x - q) >= 0.00001d * q){
            x = x * 2 / 3 + q / x / x / 3;
        }
        std::cout << x << std::endl;
    }
}

C++: #include<iostream>
#include <bits/stdc++.h>

using namespace std;

int main()
{
  double num, x0, x1 ;//?????°??£?¨?
  while(cin >> num)//??????????§?
  {
    if(num == -1) break;
    else{
      x0 = num/2.0 ;//?????????
      while(1){
        x1 = x0 - (pow(x0,3.0)-num)/(3*pow(x0,2.0)) ;//?????\????????????
        if(abs(pow(x1,3.0)-num)< 0.00001)//???????????¶?¢????
        {
          break ;
        }
        x0 = x1 ;//???????????????????????´????¬?????¨?????????????
      }
      cout<<fixed<<setprecision(8)<< x1 <<endl;
    }
  }
  return 0 ;
}

C++: #include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define mp make_pair
#define ERASE(v,i) (v).erase(remove(all(v),i),(v).end())
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define each(it,c) for(typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define debug(x) cerr<<#x<<" = "<<(x)<<endl;
#define LINE cerr<<"LINE: "<<__LINE__<<endl;
inline int toInt(string s){int v;istringstream i(s);i>>v;return v;}
template<class T> inline string toString(T x){ostringstream o;o<<x;return o.str();}
template<class T> void pv(T a,T b){for(T it=a;it!=b;++it)cerr<<*it<<" ";cerr<<endl;}
const int INF = 1000000000;
const double EPS = 1e-10;

int main() {
	for(int N; cin >> N, N != -1;) {
		printf("%.6f\n", pow(N, 1.0 / 3));
	}
}