// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> l_l;

typedef pair<int, int> i_i;

 

const long double PI = (acos(-1));

const long double EPS = 0.0000000001;

 

long double a, b, x;

 

void input() {

    cin >> a >> b >> x;

}

 

long double f(long double a, long double b, long double theta) {

    if(theta > PI / 2.0 - EPS) {

        return 0.0;

    }

    long double ret;

    if(a * tan(theta) <= b) {

        ret = a * a * b - a * a * a * tan(theta) / 2.0;

    } else {

        ret = b * b / tan(theta) * a / 2.0;

    }

    return ret;

}

 

void solve() {

    input();

    long double ok = PI / 2.0;

    long double ng = 0.0;

    for(int _ = 1; _ <= 100000; _++) {

        long double mid = (ok + ng) / 2.0;

        if(f(a, b, mid) < x) ok = mid;

        else ng = mid;

    }

    cout << fixed << setprecision(10) << ok / PI * 180 << endl;

    return;

}

 

int main() {

    solve();

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



template <typename A, typename B>

string to_string(pair<A, B> p);



template <typename A, typename B, typename C>

string to_string(tuple<A, B, C> p);



template <typename A, typename B, typename C, typename D>

string to_string(tuple<A, B, C, D> p);



string to_string(const string& s) {

    return '"' + s + '"';

}



string to_string(const char* s) {

    return to_string((string) s);

}



string to_string(bool b) {

     return (b ? "true" : "false");

}



string to_string(vector<bool> v) {

    bool first = true;

    string res = "{";

    for (int i = 0; i < static_cast<int>(v.size()); i++) {

        if (!first) {

            res += ", ";

        }

        first = false;

        res += to_string(v[i]);

    }

    res += "}";

    return res;

}



template <size_t N>

string to_string(bitset<N> v) {

    string res = "";

    for (size_t i = 0; i < N; i++) {

        res += static_cast<char>('0' + v[i]);

    }

    return res;

}



template <typename A>

string to_string(A v) {

    if(v.size() >= 200) {

        return "Too big container";

    }



    bool first = true;

    string res = "{";

    for (const auto &x : v) {

        if (!first) {

            res += ", ";

        }

        first = false;

        res += to_string(x);

    }

    res += "}";

    return res;

}



template <typename A, typename B>

string to_string(pair<A, B> p) {

    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";

}



template <typename A, typename B, typename C>

string to_string(tuple<A, B, C> p) {

    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";

}



template <typename A, typename B, typename C, typename D>

string to_string(tuple<A, B, C, D> p) {

    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";

}



void debug_out() { cerr << endl; }



template <typename Head, typename... Tail>

void debug_out(Head H, Tail... T) {

    cerr << " " << to_string(H);

    debug_out(T...);

}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)



#define rep(i,n) for (int i = 0; i < n; ++i)

#define per(i,n) for (int i = n - 1; i >= 0; --i)

#define rep1(i,n) for (int i = 1; i <= n; ++i)

#define reps(i,s,n) for (int i = s; i < n; ++i)

#define all(c) begin(c),end(c)

template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }

typedef long long ll;

typedef long double ld;

typedef pair<int,int> PINT;

typedef pair<ll,ll> PLL;

const long long MOD = 1e9+7;

#define precout() cout << std::fixed << std::setprecision(20);

#define print(a) cout << a << endl;

const int INFI = (1 << 30) - 1;

const long long INFLL = (1LL << 62) - 1;

template<typename T> void printv(vector<T>&v) {

    int n = v.size() - 1;

    rep(i, n) cout << v[i] << " ";

    cout << v.back() << endl;

}

const int dy[4] = { 0, 1, 0, -1 };

const int dx[4] = { 1, 0, -1, 0 };

const int dy8[8] = { 1, 1, 1, 0, 0, -1, -1, -1 };

const int dx8[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };

double deg2rad(double deg) { return deg * M_PI / 180; }

double rad2deg(double rad) { return rad * 180 / M_PI; }



ld A,B,X;



bool check(ld deg) {

    ld rad = deg2rad(deg);



    if(rad > M_PI / 2.0 - 0.0000000001) {

        return false;

    }



    if(B * tan(M_PI / 2 - rad) <= A) {

        return (B * tan(M_PI / 2 - rad) * B / 2 * A) >= X;

    }



    return (A * A * B - (tan(rad) * A / 2 * A * A)) >= X;

}



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    cin >> A >> B >> X;

    ld ok = 0, ng = 90;

    rep(i, 1000) {

        ld mid = (ok + ng) / 2;

        // debug(mid, check(mid));

        if(check(mid)) {

            ok = mid;

        } else {

            ng = mid;

        }

    }

    precout();

    print(ok);

}


// Fastest known solution for this problem: