#pragma region include
#include <iostream>
#include <iomanip>
#include <stdio.h>

#include <sstream>
#include <algorithm>
#include <cmath>
#include <complex>

#include <string>
#include <cstring>
#include <vector>
#include <tuple>
#include <bitset>

#include <queue>
#include <complex>
#include <set>
#include <map>
#include <stack>
#include <list>

#include <fstream>
#include <random>
//#include <time.h>
#include <ctime>
#pragma endregion //#include
/////////
#define REP(i, x, n) for(int i = x; i < n; ++i)
#define rep(i,n) REP(i,0,n)
#define ALL(X) X.begin(), X.end()
/////////
#pragma region typedef
typedef long long LL;
typedef long double LD;
typedef unsigned long long ULL;
typedef std::pair<LL,LL> PLL;//
typedef std::pair<int,int> PII;//
#pragma endregion //typedef
////定数
const int INF = (int)1e9;
const LL MOD = (LL)1e9+7;
const LL LINF = (LL)1e18+20;
const double PI = acos(-1.0);
const double EPS = 1e-9;
/////////
using namespace::std;

LD A,B,C,D;
LD X1(){
	LD a = (-27*A*A*D+9*A*B*C-2*B*B*B);
	LD b = 4*(3*A*C-B*B);
	b = b*b*b;
	a = a*a + b;
	a = sqrt(a);
	a -= 27*A*A*D+9*A*B*C-2*B*B*B;
	a = pow(a,(LD)1/3);
	LD a_ = (LD)3.0*pow(2,(LD)1/3) * A;
	a = a/a_;
	
	LD a2 = pow(2,(LD)1/3) * (3*A*C-B*B);
	LD a2_ = 3*A * a;
	a2 = a2 / a2_;
	LD ans = a + a2 - B/(3*A);
	return ans;
}

LD X2(){
	LD ans = 0;
	//i
	return ans;
}
pair<LD,LD> niji(LD A,LD B,LD C){
	pair<LD,LD> ans;
	LD D = sqrt( B*B-4*A*C );
	ans.first = (-B+D)/(2*A);
	ans.second = (-B-D)/(2*A);
	if( ans.first > ans.second ){
		swap(ans.first, ans.second);
	}
	return ans;
}
LD f(LD X){
	return A*X*X*X+B*X*X+C*X+D;
}
LD ff(LD X){
	return (LD)3.0*A*X*X+(LD)2.0*B*X+C;
}
void solve(){
	A = 1;
	cin >> B >> C >> D;
	if( B== 0 && C == 0 && D == 0 ){
		cout << "0 0 0" << endl;
	}
	/*
	解と係数の関係
	α+β+γ = -B/A
	αβ+βγ+γα = C/A
	αβγ= -D/A

	A = 1;
	α+β+γ = -B
	αβ+βγ+γα = C
	αβγ= -D
	*/
	pair<LD,LD> kabe;
	kabe = niji(3*A, 2*B,C);
	if( kabe.first < 0 ){
		kabe.first -= EPS;
	}else{
		kabe.first += EPS;
	}
	if( kabe.second < 0){
		kabe.second -= EPS;
	}else{
		kabe.second += EPS;
	}

	vector<LL> ans(3);
	LD L,R;
	L = -LINF;
	R = floor( kabe.first );

	LD mid;
	int NNN = 10000;
	bool flag = true;
	LD temp_ = ff(R);
	LD temp = f(R);
	if( f(R) < 0 ){
		flag = false;
	}
	{
		LD tempL = f(L);
		LD tempR = f(R);
		if( tempL > tempR ){
			flag = false;
		}
	}
	while(NNN--){
		mid = (L+R)/2;
		if( f(mid) > 0 ){
			if( flag ){
				R = mid;
			}else{
				L = mid;
			}
		}else{
			if( flag ){
				L = mid;
			}else{
				R = mid;
			}
		}
	}
	if( R < 0 ){
		ans[0] = R - EPS;
	}else{
		ans[0] = R + EPS;
	}
	/////
	L = floor(kabe.first);
	if( L <= ans[0] ){
		L += 1;
	}
	R = floor( kabe.second );
	{
		LD tempL = f(L);
		LD tempR = f(R);
		if( tempL > tempR ){
			flag = false;
		}
	}
	NNN = 10000;
	while(NNN--){
		mid = (L+R)/2;
		if( f(mid) > 0 ){
			if( flag ){
				R = mid;
			}else{
				L = mid;
			}
		}else{
			if( flag ){
				L = mid;
			}else{
				R = mid;
			}
		}
	}
	if( R < 0 ){
		ans[1] = R - EPS;
	}else{
		ans[1] = R + EPS;
	}
	///
	NNN = 10000;
	L = floor(kabe.second);
	if( L <= ans[1] ){
		L += 1;
	}
	R = LINF;
	flag = true;
	{
		LD tempL = f(L);
		LD tempR = f(R);
		if( tempL > tempR ){
			flag = false;
		}
	}
	
	while(NNN--){
		mid = (L+R)/2;
		if( f(mid) > 0 ){
			if( flag ){
				R = mid;
			}else{
				L = mid;
			}
		}else{
			if( flag ){
				L = mid;
			}else{
				R = mid;
			}
		}
	}
	if( R < 0 ){
		ans[2] = R - EPS;
	}else{
		ans[2] = R + EPS;
	}
	
	sort( ALL(ans) );
	if( ans[0] == -LINF || ans[1] == LINF ){
		for(int i=0;i<3;++i){
			if(i) cout << " ";
			cout << ans[1];
		}
		cout << endl;
		return;
	}
	for(int i=0;i<3;++i){
		if(i) cout << " ";
		cout << ans[i];
	}
	cout << endl;
}

#pragma region main
signed main(void){
	std::cin.tie(0);
	std::ios::sync_with_stdio(false);
	std::cout << std::fixed;//小数を10進数表示
	cout << setprecision(16);//小数点以下の桁数を指定//coutとcerrで別	

	solve();
}
#pragma endregion //main()