using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Remoting.Proxies;
using System.Security.Policy;
using static System.Console;
 
 public static class Program
 {
     private static readonly long INF = long.MaxValue / 2;
     private static readonly int MOD = 1000000007;
 
     struct Pair<T, U> : IComparable<Pair<T, U>>
         where T : IComparable<T>
         where U : IComparable<U>
     {
         public T first;
         public U second;
         private bool CompWithFirst;
 
         public Pair(T f, U s, int comp)
         {
             first = f;
             second = s;
             CompWithFirst = comp == 1;
         }
 
         public int CompareTo(Pair<T, U> other)
         {
             return CompWithFirst ? first.CompareTo(other.first) : second.CompareTo(other.second);
         }
     }
 
     public class PriorityQueue<T> where T : IComparable<T>
     {
 
         private List<T> Q;
         private readonly int r;
 
         public PriorityQueue(bool ascending)
         {
             if (ascending)
             {
                 r = 1;
             }
             else
             {
                 r = -1;
             }
 
             Q = new List<T>();
         }
 
 
         private void PushHeap(List<T> list, T item)
         {
             int n = list.Count();
             list.Add(item);
 
             while (n != 0)
             {
                 int pIndex = (n - 1) / 2;
 
                 if (list[n].CompareTo(list[pIndex]) * r > 0)
                 {
                     Swap(Q, n, pIndex);
                 }
                 else
                 {
                     break;
                 }
 
                 n = pIndex;
             }
         }
 
         private void PopHeap(List<T> list)
         {
             int n = list.Count() - 1;
             list[0] = list[n];
             list.RemoveAt(n);
 
             int cur = 0;
             int comp;
 
             while (2 * cur + 1 <= n - 1)
             {
                 int c1 = 2 * cur + 1;
                 int c2 = 2 * (cur + 1);
                 if (c1 == n - 1)
                 {
                     comp = c1;
                 }
                 else
                 {
 
                     comp = list[c1].CompareTo(list[c2]) * r > 0 ? c1 : c2;
                 }
 
                 if (list[cur].CompareTo(list[comp]) * r < 0)
                 {
                     Swap(Q, cur, comp);
                 }
                 else
                 {
                     break;
                 }
 
                 cur = comp;
             }
         }
 
         private void Swap(List<T> list, int a, int b)
         {
             T keep = list[a];
             list[a] = list[b];
             list[b] = keep;
         }
 
 
 
         public void Enqueue(T value)
         {
             PushHeap(Q, value);
         }
 
         public T Dequeue()
         {
             T ret = Q[0];
             PopHeap(Q);
             return ret;
         }
 
         public T Peek()
         {
             return Q[0];
         }
 
         public int CountItem()
         {
             return Q.Count();
         }
 
         public bool IsEmpty()
         {
             return !Q.Any();
         }
     }
 
     static long ModInv(long a, long m)
     {
         long b = m, u = 1, v = 0;
         while (b != 0)
         {
             long t = a / b;
             a -= t * b;
             long tmp = a;
             a = b;
             b = tmp;
             u -= t * v;
             tmp = u;
             u = v;
             v = tmp;
         }
 
         u %= m;
         if (u < 0) u += m;
         return u;
     }
 
     public static long CalcComb(long n, long m)
     {
         //条件チェック
         if (n < m) return 0;
         if (n < 0 || m < 0) return 0;
 
         //nＣm ＝ nＣm-1 ×（n-m+1）/ m 
 //         return CalcFact(n) / (CalcFact(m) * CalcFact(n - m));
         //MODで割ってbの逆元を求める
         return CalcFact(n) * ModInv((CalcFact(m) * CalcFact(n - m)) % MOD, MOD) % MOD;
     }
 
     /// <summary>
     /// 階乗を計算する。
     /// </summary>
     /// <param name="n">n</param>
     /// <returns>nの階乗（n!）</returns>
     public static long CalcFact(long n)
     {
         if (n <= 0)
         {
             return 1;
         }
 
         return n * CalcFact(n - 1) % MOD;
     }


     partial struct Pos
     {
         public int x;
         public int y;
 
         public Pos(int x, int y)
         {
             this.x = x;
             this.y = y;
         }
         
         public static Pos operator +(Pos p1, Pos p2)
         {
             var result = new Pos();
             result.x = p2.x + p1.x;
             result.y = p2.y + p1.y;
             return result;
         }
 
         public static Pos operator -(Pos p1, Pos p2)
         {
             var result = new Pos();
             result.x = p2.x - p1.x;
             result.y = p2.y - p1.y;
             return result;
         }
     }
     
     class Modular
     {
         private const int M = 1000000007;
         private long value;
 
         public Modular(long value)
         {
             this.value = value;
         }
 
         public static implicit operator Modular(long a)
         {
             var m = a % M;
             return new Modular((m < 0) ? m + M : m);
         }
 
         public static Modular operator +(Modular a, Modular b)
         {
             return a.value + b.value;
         }
 
         public static Modular operator -(Modular a, Modular b)
         {
             return a.value - b.value;
         }
 
         public static Modular operator *(Modular a, Modular b)
         {
             return a.value * b.value;
         }
 
         private static Modular Pow(Modular a, int n)
         {
             switch (n)
             {
                 case 0:
                     return 1;
                 case 1:
                     return a;
                 default:
                     var p = Pow(a, n / 2);
                     return p * p * Pow(a, n % 2);
             }
         }
 
         public static Modular operator /(Modular a, Modular b)
         {
             return a * Pow(b, M - 2);
         }
 
         private static readonly List<int> facs = new List<int> {1};
 
         private static Modular Fac(int n)
         {
             for (int i = facs.Count; i <= n; ++i)
             {
                 facs.Add((int) (Math.BigMul(facs.Last(), i) % M));
             }
 
             return facs[n];
         }
 
         public static Modular Ncr(int n, int r)
         {
             return (n < r) ? 0
                 : (n == r) ? 1
                 : Fac(n) / (Fac(r) * Fac(n - r));
         }
 
         public static explicit operator int(Modular a)
         {
             return (int) a.value;
         }
     }
     
     static class Permutation<T>
     {
         private static void Search(List<T[]> perms, Stack<T> stack, T[] a)
         {
             int N = a.Length;
             if (N == 0)
             {
                 perms.Add(stack.Reverse().ToArray());
             }
             else
             {
                 var b = new T[N - 1];
                 Array.Copy(a, 1, b, 0, N - 1);
                 for (int i = 0; i < a.Length; ++i)
                 {
                     stack.Push(a[i]);
                     Search(perms, stack, b);
                     if (i < b.Length) { b[i] = a[i]; }
                     stack.Pop();
                 }
             }
         }
         public static IEnumerable<T[]> All(IEnumerable<T> src)
         {
             var perms = new List<T[]>();
             Search(perms, new Stack<T>(), src.ToArray());
             return perms;
         }
     }
 
     public static int ReadLineToInt()
     {
         return int.Parse(ReadLine());
     }
     
     public static long ReadLineToLong()
     {
         return long.Parse(ReadLine());
     }
     
     public static int[] ReadLineToInts()
     {
         return ReadLine().Split(' ').Select(int.Parse).ToArray();
     }
     
     public static long[] ReadLineToLongs()
     {
         return ReadLine().Split(' ').Select(long.Parse).ToArray();
     }
     
     static int nibunn(int[] array, int target)
     {
         int L = 0;
         int R = array.Length; 
             
         while(R - L > 1)
         {
             int mid = (R + L) / 2;
             if (array[mid] > target) L = mid;
             else R = mid;
         }
         return L;
     }

     struct P
     {
         public int first;
         public int second;

         public P(int a, int b)
         {
             first = a;
             second = b;
         }
     }
    
     static long GCD(long x, long y)
     {
         if (y == 0) return x;
         return GCD(y, x%y);
     }

     static P f(int x)
     {
         int a = x % 10;
         int b = 0;
         while (x != 0)
         {
             b = x;
             x /= 10;
         }
         return new P(a,b);
     }

//     static void dfs(int v, int p = -1)
//     {
//         
//         foreach (var e in Tree[0])
//         {
//             dfs(e, v);
//         }
//     }
//     static List<int>[] Tree;
//     private static int[,] Edge;
//
//     static void SetColor(int v1, int v2, int c)
//     {
//         if (v1 < v2)
//         {
//             Edge[v1, v2] = c;
//         }
//         else
//         {
//             Edge[v2, v1] = c;
//         }
//     }
//     public static void Main(string[] args)
//     {
//         int n = ReadLineToInt();
//         Tree = new List<int>[n];
//         Edge = new int[n-1,n-1];
//         for (int i = 0; i < n; i++)
//         {
//             Tree[i] = new List<int>();
//         }
//         
//         for (int i = 0; i < n-1; i++)
//         {
//             for (int j = 0; j < n - 1; j++)
//             {
//                 Edge[i, j] = INF;
//             }
//         }
//
//         
//         for (int i = 0; i < n-1; i++)
//         {
//             var l1 = ReadLineToInts();
//             int a = l1[0];
//             int b = l1[1];
//             a--;
//             b--;
//             Tree[a].Add(b);
//             Tree[b].Add(a);
//         }
//         
//         dfs(0);
//     }
     const double EPS = 0.0000000001;
     static double  F(double a, double b, double theta) {
         if(theta > Math.PI / 2.0 - EPS) {
             return 0.0;
         }
         double ret;
         if(a * Math.Tan(theta) <= b) {
             ret = a * a * b - a * a * a * Math.Tan(theta) / 2.0;
         } else {
             ret = b * b / Math.Tan(theta) * a / 2.0;
         }
         return ret;
     }

     public static void Main(string[] args)
     {
         var l = ReadLineToInts();
         int a = l[0];
         int b = l[1];
         int x = l[2];
         double ok = Math.PI / 2.0;
         double ng = 0.0;
         for(int _ = 1; _ <= 100000; _++) {
             double mid = (ok + ng) / 2.0;
             if(F(a, b, mid) < x) ok = mid;
             else ng = mid;
         }
         WriteLine($"{ok / Math.PI * 180:f10}");
     }
 }

Measured memory_bytes: 13396