#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> p64;
typedef vector<ll> v64;
typedef vector<v64> vv64;
typedef vector<p64> vp64;

#define PI 3.141592653589793238462643383279502884L

ll r, s, h;
std::map<v64, ld> err;

ld getErr(ld rem, v64 v) {
    return abs(rem - (1.0L/v[0]) + (1.0L/v[1]/v[2]) - (1.0L/v[1]/v[2]/v[3]));
}

void rec1(ld rem, ld range, v64 v);
void rec2(ld rem, ld range, v64 v);
void rec3(ld rem, ld range, v64 v);

void rec1(ld rem, ld range, v64 v) {
    // cout << "rem1: " << rem << endl;
    for (ll i=2; i<=1000/4; i++) {
        if (range/i > rem) {
            v[0] = i;
            ld nrem = (range/i) - rem;
            ld nrange = (range/i);
            rec2(nrem, nrange, v);
        } else {
            v[0] = i;
            v[1] = 1000L / (2*v[0]);
            v[2] = 2;
            err[v] = abs(rem - (1.0L/v[0]) + (1.0L/v[1]/v[2]) - (1.0L/v[1]/v[2]/v[3]));
            return;
        }
    }
}

void rec2(ld rem, ld range, v64 v) {
    // cout << "rem2: " << rem << endl;
    for (ll i=2; i<=1000/(2*v[0]); i++) {
        if (range/i > rem) {
            v[1] = i;
            ld nrem = (range/i) - rem;
            ld nrange = (range/i);
            rec3(nrem, nrange, v);
        } else {
            v[1] = i;
            v[2] = 1000L / (v[1]);
            err[v] = abs(rem - (1.0L/v[1]/v[2]) + (1.0L/v[1]/v[2]/v[3]));
            return;
        }
    }
}

void rec3(ld rem, ld range, v64 v) {
    // cout << "rem3: " << rem << endl;
    ll maxi = 1000 / (v[0]*v[1]);
    if (range > maxi * rem) {
        v[2] = maxi;
        err[v] = abs(rem - (range / maxi));
    } else {
        v[2] = (ll)(range/rem);
        err[v] = abs(rem - (range / v[2]));
        v[2]++;
        err[v] = abs(rem - (range / v[2]));
    }
}

int main () {
    cin >> r >> s >> h;

    ld rem = 2.0L*PI*r / s / h;
    rem = rem - (ll)rem;
    if (rem > 0.5L) {
        rem = 1.0L-rem;
    }
    rec1(rem - (ll)rem, 1.0L, {0, 0, 0});

    v64 pattern = {0, 0, 0};
    ld minErr = 1.0;
    for (auto entry : err) {
        // cout << entry.second << endl;
        if (entry.second < minErr) {
            minErr = entry.second;
            pattern = entry.first;
        }
    }

    cout << pattern[0] << " " << pattern[0]*pattern[1] << " " << pattern[0]*pattern[1]*pattern[2] << endl;

    return 0;
}