using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

namespace AtCoder
{
    static class Program_D
    {
        class Solver
        {
            int ri => sc.Integer();
            long rl => sc.Long();
            double rd => sc.Double();
            string rs => sc.Scan();
            public StreamScanner sc = new StreamScanner(Console.OpenStandardInput());

            private double a;
            private double b;
            private double x;
            private double edgeRot;


            // ABC144D Water bottle
            public void Solve()
            {
                a = ri;
                b = ri;
                x = ri / a;
                double err;
                double[] range = new double[] { 0, Math.PI/2 };

                edgeRot = Math.Atan(b / a);

                //PlotValues();


                double mid = (range[0] + range[1]) / 2;
                do
                {
                    double vol = CalcVol(mid);
                    range[vol > x ? 0 : 1] = mid;
                    double newMid = (range[0] + range[1]) / 2;
                    err = Math.Abs(mid - newMid);
                    mid = newMid;
                } while (err > 0.00000000001);
                Wl(ToDeg(mid));                
            }

            private void PlotValues()
            {
                for(double degree=0; degree < 90; degree += 1)
                {
                    var vol = CalcVol(Math.PI * degree / 180.0);
                    Console.WriteLine(vol);
                }
            }

            double CalcVol(double theta)
            {
                if (theta < edgeRot)
                {
                    // 水が半分以上入っており、角に来るまでの間にあふれる。
                    // c: b側の辺の空白部の長さ
                    double c = a * Math.Tan(theta);
                    return a * b - (a * c) / 2;
                }
                else
                {
                    // 水が半分未満入っており、角以降であふれる。
                    // c: a側の辺の実部の長さ
                    double c = b / Math.Tan(theta);
                    return (c * b) / 2;
                }
                //return rot < edgeRot ? CalcVol1(rot) : CalcVol2(rot);
            }
            // 水が半分以上入っており、角に来るまでの間にあふれる。
            //private double CalcVol1(double theta)
            //{
            //    // c: b側の辺の空白部の長さ
            //    double c = a * Math.Tan(theta);
            //    return a * b - (a * c) / 2;
            //}

            //// 水が半分未満入っており、角以降であふれる。
            //private double CalcVol2(double theta)
            //{
            //    // c: a側の辺の実部の長さ
            //    double c = b / Math.Tan(theta);
            //    return (c * b) / 2;
            //}

            // ABC144D Water bottle
            //public void Solve()
            //{
            //    a = ri;
            //    b = ri;
            //    x = ri / a;
            //    if (x > (a * b) / 2)
            //        BinSearch(new double[] { 0, Math.Atan2(b, a) }, v => CalcVol1(v));
            //    else
            //        BinSearch(new double[] { Math.Atan2(b, a), Math.PI / 2 }, v => CalcVol2(v));
            //}

            //private void BinSearch(double[] range, Func<double, double> calculator)
            //{
            //    double err;
            //    double mid = (range[0] + range[1]) / 2;
            //    do
            //    {
            //        double vol = calculator(mid);
            //        range[vol > x ? 0 : 1] = mid;
            //        double newMid = (range[0] + range[1]) / 2;
            //        err = Math.Abs(mid - newMid);
            //        mid = newMid;
            //    } while (err > 0.00000000001);
            //    Wl(ToDeg(mid));
            //}


            double ToDeg(double rad)
            {
                return 180 * (rad / Math.PI);
            }

          

            private void Combination(int m, int n)
            {
                var result = Fact(m) / (Fact(n) * Fact(m - n));
                Wl(result);
            }

            ModInt Fact(int a)
            {
                ModInt result = new ModInt(1);
                for(int i = 2; i <= a; ++i)
                {
                    result *= i;
                }
                return result;

            }

            int[] CalcAb(int x, int y)
            {
                var tmp = 2 * x - y;
                if (tmp % 3 != 0) return null;
                var b = tmp / 3;
                var a = x - 2 * b;
                if (a < 0 || b <0) return null;

                return new[] { a, b };
            }


            // ----------------------------------------------------------------------------
            static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }


            string Rl()
            {
                return Console.ReadLine();
            }
            void Wl(UInt64 val)
            {
                Console.WriteLine(val);
            }
            void Wl(Int64 val)
            {
                Console.WriteLine(val);
            }
            void Wl(uint val)
            {
                Console.WriteLine(val);
            }
            void Wl(int val)
            {
                Console.WriteLine(val);
            }
            void Wl(double val)
            {
                Console.WriteLine(val);
            }
            void Wl(string mes)
            {
                Console.WriteLine(mes);
            }
            public int Int()
            {
                return int.Parse(Console.ReadLine());
            }

            public int[] Ints(int subtract)
            {
                return Console.ReadLine().Split(' ').Select(s => int.Parse(s) - subtract).ToArray();
            }
            public Int64[] Int64s(Int64 subtract)
            {
                return Console.ReadLine().Split(' ').Select(s => Int64.Parse(s) - subtract).ToArray();
            }
            public UInt64[] UInt64s(UInt64 subtract)
            {
                return Console.ReadLine().Split(' ').Select(s => UInt64.Parse(s) - subtract).ToArray();
            }


        }



        static void Main(string[] args)
        {
            //Console.SetOut(new Printer(Console.OpenStandardOutput()) { AutoFlush = false });
            new Solver().Solve();
            //Console.Out.Flush();
        }
    }

    public class Printer : StreamWriter
    {
        public override IFormatProvider FormatProvider => CultureInfo.InvariantCulture;
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }

    public class StreamScanner
    {
        public StreamScanner(Stream stream) { str = stream; }

        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;

        private byte read()
        {
            if (isEof) return 0;
            if (ptr >= len)
            {
                ptr = 0;
                if ((len = str.Read(buf, 0, 1024)) <= 0)
                {
                    isEof = true;
                    return 0;
                }
            }
            return buf[ptr++];
        }

        public char Char()
        {
            byte b = 0;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            return (char)b;
        }
        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }

    struct ModInt
    {
        const int MOD = 1000000007;
        long Data;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ModInt(long data) { if ((Data = data % MOD) < 0) Data += MOD; }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator long(ModInt modInt) => modInt.Data;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator ModInt(long val) => new ModInt(val);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, ModInt b)
        {
            long res = a.Data + b.Data;
            return new ModInt() { Data = res >= MOD ? res - MOD : res };
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, long b) => a.Data + b;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, ModInt b)
        {
            long res = a.Data - b.Data;
            return new ModInt() { Data = res < 0 ? res + MOD : res };
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, long b) => a.Data - b;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator *(ModInt a, ModInt b) => new ModInt() { Data = a.Data * b.Data % MOD };
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator /(ModInt a, ModInt b) => a.Data * GetInverse(b);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public override string ToString() => Data.ToString();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static long GetInverse(long a)
        {
            long div;
            long p = MOD;
            long x1 = 1, y1 = 0, x2 = 0, y2 = 1;
            while (true)
            {
                if (p == 1) return x2;
                div = a / p;
                x1 -= x2 * div;
                y1 -= y2 * div;
                a %= p;
                if (a == 1) return x1;
                div = p / a;
                x2 -= x1 * div;
                y2 -= y1 * div;
                p %= a;
            }
        }
    }

}

Measured memory_bytes: 27836