Problem:
 Score : 400 points    Problem Statement Takahashi has a water bottle with the shape of a rectangular prism whose base is a square of side a~\mathrm{cm} and whose height is b~\mathrm{cm} . (The thickness of the bottle can be ignored.)  We will pour x~\mathrm{cm}^3 of water into the bottle, and gradually tilt the bottle around one of the sides of the base.  When will the water be spilled? More formally, find the maximum angle in which we can tilt the bottle without spilling any water.      Constraints  All values in input are integers.  1 \leq a \leq 100  1 \leq b \leq 100  1 \leq x \leq a^2b         Input Input is given from Standard Input in the following format:  a  b  x       Output Print the maximum angle in which we can tilt the bottle without spilling any water, in degrees.
Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6} .        Sample Input 1 2 2 4      Sample Output 1 45.0000000000  This bottle has a cubic shape, and it is half-full. The water gets spilled when we tilt the bottle more than 45 degrees.       Sample Input 2 12 21 10      Sample Output 2 89.7834636934  This bottle is almost empty. When the water gets spilled, the bottle is nearly horizontal.       Sample Input 3 3 1 8      Sample Output 3 4.2363947991  This bottle is almost full. When the water gets spilled, the bottle is still nearly vertical.

Solution (Python):


from math import atan, degrees

a, b, x = map(int, input().split())
volume = a * a * b

if x * 2 >= volume:
  h = 2 * b - 2 * x / (a * a)
  print(degrees(atan(h / a)))
else:
  h = 2 * x / (a * b)
  print(degrees(atan(b / h)))

Solution (Python):
a,b,x=list(map(int,input().split()))
import math
x=x/a
if a*b/2<x:
   print(math.degrees(math.atan(2*(a*b-x)/a**2)))
else:
   print(math.degrees(math.atan(b**2/(2*x))))

Solution (Python):


from math import pi, tan, atan, degrees

a, b, x = [int(i) for i in input().split()]

theta = (pi * 0.5) - atan(2 * x / (a * b**2))

if b * tan(pi * 0.5 - theta) <= a:
    print(degrees(theta))

else:
    theta = atan(((2 * b) / a) - (2 * x / a**3))
    print(degrees(theta))

Solution (Python):

from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify

import itertools
import math, fractions
import sys, copy

def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]

def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))

def make_list(n, *args, default=0): return [make_table(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]

alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
INF = float("inf")

def main():
    a, b, x = LI()

    if x <= a * a * b / 2:
        c = 2 * x / (a * b)
        rad = math.atan(b / c)
    else:
        x = a * a * b - x
        c = 2 * x / (a * a)
        rad = math.atan(c / a)
    print(math.degrees(rad))

if __name__ == '__main__':
    main()

Solution (Python):


from math import pi, tan

a, b, x = map(int, input().split())
eps = 10e-8

def f(a, b, theta):
    if theta > pi / 2.0 - eps:
        return 0.0
    ret = 0.0
    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

ng = 0.0
ok = pi / 2.0
for _ in range(100000):
    mid = (ok + ng) / 2.0
    if f(a, b, mid) < x:
        ok = mid
    else:
        ng = mid
print("{:.10f}".format(ok / pi * 180))

Solution (Python):
a, b, x = map(int, input().split())
import math

S = a*b
s = x/a
if s == S:
  print(0)

elif s >= S/2:
  em_s = S-s
  tan = (a**2)/(2*em_s)
  ans = math.degrees(math.atan(tan))
  print(90-ans)

else:
  tan = (2*s)/(b**2)
  ans = math.degrees(math.atan(tan))
  print(90-ans)

Solution (Python):

import math







a, b, x = map(int, input().split())





































x_s = a * a * b - x
if x <= x_s:
    print(math.degrees(math.atan(a * b * b / (2 * x))))
else:
    print(math.degrees(math.atan(2 * x_s / (a * a * a))))

Solution (Python):
'''
Created on 2020/08/27

@author: harurun
'''
def main():
  import math
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write
  
  a,b,x=map(int,pin().split())
  if 2*x>a*a*b:
    print(math.degrees(math.atan((2*b*a*a-2*x)/(a*a*a))))
  else:
    print(math.degrees(math.atan(a*b*b/(2*x))))
  return 

main()

Solution (Python):
import math
a,b,x = map(int,input().split())

if x >= a**2*b/2:
  y = 2*(a**2*b-x)/(a**2)
  ans = math.degrees(math.atan(y/a))
else:
  y = 2*x/(a*b)
  ans = math.degrees(math.atan(b/y))
print(ans)

Solution (Python):
import math

a, b, x = map(int, input().split())

s = x / a

if s >= a * b / 2:
    h = (a * b - s) * 2 / a
    rad = math.atan2(h, a)
else:
    w = s * 2 / b
    rad = math.atan2(b, w)

print(rad / (2 * math.pi) * 360)

Solution (Python):
import math
a, b, x = map(int, input().split())
water_h = x / (a * a)
rest_b = b - water_h
if x > (a * a * b) / 2:
    ans = math.degrees(math.atan(rest_b/(a / 2)))
else:
    x /= a
    water_h = (2 * x) / b
    ans = math.degrees(math.atan(b / water_h))
print(ans)

Solution (Python):
import math
a, b, x = map(int, input().split())
if a * a * b >= 2 * x:
  print(math.degrees(math.atan((a * b * b) / (x * 2.0))))
else:
  v = a * a * b - x
  print(math.degrees(math.atan((2.0 * v) / (a * a * a))))

Solution (Python):
import math
a, b, x = map(int, input().split())
x = x / a
if x >= a*b/2:
  K = (a*b - x)/a*2
  L = K/math.sqrt(K**2+a**2)
  ans = math.degrees(math.asin(L))
  print(ans)
else:
  K = 2*x/b
  L = b/math.sqrt(K**2+b**2)
  ans = math.degrees(math.asin(L))
  print(ans)

Solution (Python):
a, b, x = map(int, input().split())

import math
if x <= ((a ** 2) * b) / 2:
    n = 2 * x / (a * b)
    ans = math.acos(n / (math.sqrt(b ** 2 + n ** 2)))
else:
    n = 2 * b - (2 * x / (a ** 2))
    ans = math.acos(a / math.sqrt(a ** 2 + n ** 2))

print(math.degrees(ans))

Solution (Python):
from math import atan, degrees
a,b,x=list(map(int, input().split()))
V=a**2*b
if 2*x<=V:
    t=a*b**2/(2*x)
else:
    t=(2*(V-x))/a**3
print(degrees(atan(t)))

Solution (Python):
from math import atan, degrees
a, b, x = map(int, input().split())

if a*a*b <= 2*x:
    theta = degrees(atan(2*b/a-2*x/(a*a*a)))
else:
    theta = degrees(atan(a*b*b/(2*x)))
print(theta)

Solution (Python):
import math

a,b,x = map(int, input().split())

if x >= a*a*b / 2:
  tan = ((a*a*b - x) * 2) / a**3
  print(math.degrees(math.atan(tan)))

else:
  tan = 2*x / (a*b*b)
  print(90 - math.degrees(math.atan(tan)))

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,x = I()

if (a**2*b)<=2*x:
    c = 2*(a**2*b-x)/a**3
else:
    c = (a*b**2)/(2*x)

print(math.degrees(math.atan(c)))

Solution (Python):
import math

a,b,x = map(int,input().split())
c = 2*x/(a*b)

if c <= a:
    ans = 90 - math.degrees(math.atan(c/b))
    
else:
    d = 2*(a**2 * b - x)/a**2
    
    if d == 0:
        ans = 0
    else:
        ans = 90 - math.degrees(math.atan(a/d))
    
print(ans)

Solution (Python):
from math import degrees, atan

a, b, x = map(int, input().split())

if a * a * b < x * 2:
    c = 2 * (a * a * b - x) / a ** 3
else:
    c = a * b * b / (2 * x)

print(degrees(atan(c)))

Solution (Python):
import math
def main():
    a, b, x = map(int, input().split())

    ans = 0
    if 2*x >= (a**2)*b:
        ans = math.atan((x/a - a*b)*(-2/a**2))*180/math.pi
    else:
        ans = math.atan(a*b**2/(2*x))*180/math.pi

    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
import math

a, b, x = [int(_) for _ in input().split()]

h = x / a / a
if a * b / 2 < a * h:
    theta = math.atan(2 * (b - h) / a)
else:
    theta = math.atan(b * b / a / h / 2)

ans = math.degrees(theta)
print(ans)

Solution (Python):
a,b,x = map(int,input().split())
s = a*a*b

import math
if x<=s/2:
    ans = math.degrees(math.atan((a*b*b)/(2*x)))
else:
    ans = math.degrees(math.atan(2*(a*a*b-x)/(a**3)))
print(ans)

Solution (Python):
import math
a, b, x = list(map(int, input().split()))

if x/a < a*b/2:
    print(math.atan(a*b*b/(2*x))*180/math.pi)
else:
    print(math.atan(2/a * (b-x/a**2))*180/math.pi)

Solution (Python):
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy


import heapq
sys.setrecursionlimit(10**6)

INF = 10**18
import bisect
import statistics
mod = 10**9+7


a, b, x = map(int, input().split())

if x <= a**2*b/2.0:
    print(math.atan(a*b**2/(2.0*x))*180/math.pi)
else:
    z = a**2*b - x
    print(math.atan((2.0*z)/(a**3))*180/math.pi)

Solution (Python):
import math
a, b, x = map(int, input().split())
full = a * a * b
if x > full / 2:
    x = full - x
    tan_x = 2.0 * x / (a*a) / a
    print(math.atan(tan_x) / math.pi * 180.0)
else:
    tan_x = 2.0 * x / (a*b) / b
    print(90-math.atan(tan_x) / math.pi * 180.0)

Solution (Python):
import math
a,b,x=map(int,input().split())
s=a*a*b
if x>=s/2:
  tmp=(s-x)/a/a*2
  print(math.degrees(math.atan(tmp/a)))
else:
  tmp=x/a/b*2
  print(90.0-math.degrees(math.atan(tmp/b)))

Solution (Python):
a,b,x=map(int,input().split())
import math
v=a*a*b
if x>=v/2:
    print(180*math.atan(2*(v-x)/(a*a*a))/math.pi)
else:
    print(90-(180*math.atan(2*x/(a*b*b)))/math.pi)

Solution (Python):
import math

def resolve():
    a, b, x = map(int, input().split())
    met = a ** 2 * b / 2
    if x > met:
        y = 2 * b - 2 * x / a**2
        ans = math.atan2(y, a)
    elif x == met:
        ans = math.pi / 4
    else:
        y = 2 * x / a / b
        ans = math.pi / 2 - math.atan2(y, b)

    print(math.degrees(ans))
    
resolve()

Solution (Python):
import math

a, b, x = map(int, input().split())

if  2 * x <= a ** 2 * b:
    ans = math.atan(a*b**2/2/x)
else:
    ans = math.atan(2*(a**2*b-x)/a**3)
print(math.degrees(ans))

Solution (Python):
from math import atan, pi
a, b, x = map(int, input().split())

if x > a * a * b / 2:
    h = 2 * x / (a * a) - b
    ans = atan((b - h) / a)
else:
    h = 2 * x / (a * b)
    ans = pi / 2 - atan(h/b)

ans *= 180 / pi
print("{:.12f}".format(ans))

Solution (Python):
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import math

ans = 0
a, b, x = map(int, input().split())
S = x / a
if S >= (a * b / 2):
    h = ((a * b - S) * 2) / a
    deg = math.atan2(h, a) / (math.pi * 2) * 360
else:
    w = 2 * S / b
    deg = math.atan2(b, w) / (math.pi * 2) * 360
print(deg)

Solution (Python):
import math
a, b, x = map(int, input().split())
if a*a*b==x:
    print(0)
elif a*a*b<=2*x:
    print(90-math.degrees(math.atan(a**3/(2*b*a*a-2*x))))
else:
    print(90-math.degrees(math.atan(2*x/(a*b*b))))

Solution (Python):
import math
a,b,x = map(int,input().split())
if x > a*a*b/2:
    tan = 2*(a*a*b - x)/(a*a*a)
elif x <= a*a*b/2:
    tan = a*b*b/(2*x)
print(math.degrees(math.atan(tan)))

Solution (Python):
import math

a, b, x = map(int, input().split())
if x <= a*a*b/2:
  print(math.degrees(math.atan(a*b*b/(2*x))))
else:
  print(math.degrees(math.atan(2*(a*a*b-x)/(a**3))))

Solution (Python):

from math import degrees, atan2

a, b, x = [int(x) for x in input().split()]
if x <= a ** 2 * b / 2:
    ans = degrees(atan2(a * b ** 2, 2 * x))
else:
    ans = degrees(atan2(2 * a ** 2 * b - 2 * x, a ** 3))

print(ans)

Solution (Python):
import math
a,b,x = map(int,input().split())
if x >= a**2*b/2:
    deg = (2*(a*a*b-x))/a**3
    print(math.degrees(math.atan(deg)))
else:
    deg = a*b*b/(2*x)
    print(math.degrees(math.atan(deg)))

Solution (Python):
import math

a,b,x = map(int, input().split())

vol = a*a*b

if x > vol/2:
    ans = math.atan(2*(vol-x)/ a**3)
else:
    ans = math.atan((a*b**2)/(2*x))

print(math.degrees(ans))

Solution (Python):
import math
a, b, x = map(int, input().split())
theta = math.atan((-2) * x / (a ** 3) + 2 * b / a)
if a * math.tan(theta) > b:
    theta = math.atan2(a * b * b, 2 * x)
print(math.degrees(theta))

Solution (Python):
import math
a, b, x = map(int, input().split())
ans = 0

if a*a*b/2 < x:
    t = 2*x/(a*a) - b
    ans =  math.degrees(math.atan((b-t)/a))
else:
    t = 2*x/(a*b)
    ans = math.degrees(math.atan(b/t))

print(ans)

Solution (Python):
import math
a, b, x = map(int, input().split())
if x <= a * a * b / 2:
    t = 2 * x / a / b
    theta = math.atan2(b, t) / math.pi * 180
else:
    y = a * a * b - x
    t = 2 * y / a / a
    theta = math.atan2(t, a) / math.pi * 180
print(theta)

Solution (Python):
import math

a,b,x = [int(i) for i in input().split()]
s = x / a
if s<=a*b/2:
    print(math.atan(b**2/(2*s))/math.pi*180)
else:
    print(math.atan(2*(a*b-s)/(a**2))/math.pi*180)

Solution (Python):
import math
a,b,x = map(int,input().split())
S = a*a*b
if 2*x>=S:
    tmp = 2 * (S - x) / (a**3)
else:
    tmp = a * b * b / (2 * x)
print(math.degrees(math.atan(tmp)))

Solution (Python):
import sys
readline = sys.stdin.readline

A,B,X = map(int,readline().split())

bottle = (A ** 2) * B
x = -1
y = -1
import math
area = X / A
if X < bottle / 2:
  y = (X * 2 / B) / A
  x = B
  print(90 - math.degrees(math.atan(y/x)))
else:
  x = (bottle - X) * 2 / (A ** 2)
  y = A
  if x == 0:
    print(0)
  else:
    print(90 - math.degrees(math.atan(y/x)))

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b, x = rm()
x /= a
if a*b / 2 >= x:
    a = 2*x / b
    print(90 - math.degrees(math.atan(a/b)))
else:
    x = a*b - x
    b = 2*x / a
    print(math.degrees(math.atan(b/a)))

Solution (Python):
import math
a,b,x=map(int,input().split())

if x<=a*a*b/2:
    print(90-math.degrees(math.atan(2*x/a/b/b)))
else:
    print(math.degrees(math.atan(2*(a*b-x/a)/a/a)))

Solution (Python):
from decimal import Decimal
import math

a, b, x = list(map(Decimal, input().split()))

if a * a * b > 2 * x:
    tri = x / a
    c = tri * Decimal(2) / b
    d = (c ** 2 + b ** 2) ** Decimal("0.5")
    cos_a = (b ** 2 + d ** 2 - c ** 2) / (2*b*d)
    print(90 - math.degrees(math.acos(cos_a)))
else:
    tri = (a * a * b - x) / a
    e = tri * Decimal(2) / a
    f = (a ** 2 + e ** 2) ** Decimal("0.5")
    cos_e = (f ** 2 + a ** 2 - e ** 2) / (2*f*a)
    print(math.degrees(math.acos(cos_e)))

Solution (Python):
from math import degrees,atan2
a,b,x = map(int, input().split())
ans = 0
if (a*a*b/2 >= x):
    ans = degrees(atan2(a*b*b,2*x))
else:
    x = a*a*b - x
    ans = degrees(atan2(2*x,a*a*a))

print(ans)

Solution (Python):
import math

a,b,x=map(int,input().split())

if x>(a**2)*b/2:
    print(math.degrees(math.atan(2*(b-x/(a**2))/a)))
else:
    print(math.degrees(math.atan(a*(b**2)/(2*x))))

Solution (Python):
import math
a, b, x = map(int, input().split())
maxx = a * a * b
ans_rad = 0
if x + x <= maxx:
    c = 2 * x / (a * b)
    ans_rad = math.atan(b / c)
else:
    y = maxx - x
    c = 2 * y / (a * a)
    ans_rad = math.atan(c / a)

ans = math.degrees(ans_rad)
print(ans)

Solution (Python):








def solve(a, b, x):
    import math
    LOOP = 100
    water_max = a ** 2 * b
    area_x = x / a
    half_angle = math.degrees(math.acos(a / math.sqrt(a ** 2 + b ** 2)))
    ans = 0
    if x > water_max / 2:
        top = half_angle
        btm = 0
        for _ in range(LOOP):
            ans = (top + btm) / 2
            angle_a = 90 - ans
            angle_b = ans
            angle_c = 90
            side_a = a  
            side_c = a / math.cos(math.radians(angle_b))
            side_b = side_c * math.sin(math.radians(angle_b))  
            area = side_a * side_b / 2 + side_a * (b - side_b)
            if area >= area_x:
                btm = ans
            else:
                top = ans
    else:
        top = 90
        btm = half_angle
        for _ in range(LOOP):
            ans = (top + btm) / 2
            angle_a = 90 - ans
            angle_b = ans
            angle_c = 90
            side_b = b  
            side_c = b / math.sin(math.radians(angle_b))
            side_a = side_c * math.cos(math.radians(angle_b))  
            area = side_a * side_b / 2
            if area >= area_x:
                btm = ans
            else:
                top = ans

    print(ans)


if __name__ == '__main__':
    
    
    a, b, x = map(int, input().split())
    
    
    solve(a, b, x)

Solution (Python):

from math import atan, sqrt, degrees

a,b,x = map(int, input().split())

ans = 0

if x <= a*a*b/2:
    ans = degrees(atan(a*b*b/(2*x)))
else:
    ans = degrees(atan((2*b-2*x/(a*a))/a))

print(ans)

Solution (Python):
import math

def cin():
    in_ = list(map(int,input().split()))
    if len(in_) == 1:  return in_[0]
    else:  return in_

a, b, x = cin()
if a * a * b == x:  print(0)
else:
    if 2 * x <= a ** 2 * b:
        p = 2 * x / (a * b)
        print(math.degrees(math.atan(b / p)))
    else:
        S = x / a
        p = 2 * (a * b - S) / a
        print(90 - math.degrees(math.atan(a / p)))

Solution (Python):
import math
a,b,x = list(map(int,input().split()))

check = a*a*b/2

if x >= check: 
    ans = math.degrees(math.atan(2*(b/a-x/(a**3))))
else :
    c_=a*b*b/2
    ans = math.degrees(math.atan((c_/x)))
    
print(ans)

Solution (Python):
from math import atan2, degrees

A, B, X = map(int, input().split())
if A ** 2 * B > X * 2:
    width = X * 2 / (A * B)
    print(degrees(atan2(B, width)))
else:
    height = (A ** 2 * B - X) * 2 / (A ** 2)
    print(degrees(atan2(height, A)))

Solution (Python):
import math

a,b,x = map(int,input().split())

h1 = b - x/a/a
h2 = 2*x/(a*b)


if x == a*a*b:
    print(0)
elif b*a*a/2 <= x:
    radians = math.atan(a/2/h1)
    print(90 - math.degrees(radians))
else:
    radians = math.atan(h2/b)
    print(90 - math.degrees(radians))

Solution (Python):

import math

a, b, x = list(map(int, input().split()))
if a * a * b * (1/2) <= x:
    tmp = 2 * (a*a*b-x) / (a*a*a)
    print(math.degrees(math.atan(tmp)))
else:
    tmp = a*b*b / (2*x)
    print(math.degrees(math.atan(tmp)))

Solution (Python):
from math import atan,pi
A,B,X=map(int,input().split())

if 2*X>=A*A*B:
    P=atan(2*(A*A*B-X)/(A*A*A))*180/pi
    print(P)
else:
    Q=atan((A*B*B)/(2*X))*180/pi
    print(Q)

Solution (Python):
import math
a,b,x = map(int,input().split())
if x <= b*a*a*1/2:
    dum = 2*x/(a*b)
    ans = 90-(math.degrees(math.atan(dum/b)))
else:
    x -= b*a*a*1/2
    dum = b-(x*2/(a*a))
    ans = math.degrees(math.atan(dum / a))
print(ans)

Solution (Python):
import sys
import math

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    a, b, x = map(int, readline().split())
    V = a * a * b / 2
    if V < x:
        ans = math.degrees(math.atan((2 * (a * a * b - x)) / a ** 3))
    else:
        ans = math.degrees(math.atan((a * b * b) / (2 * x)))
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import math
a,b,x = map(int,input().split())
if a**2*b < 2*x:
    print(math.degrees(math.atan(2*b/a - 2*x/a**3 )))
else:
    print(math.degrees(math.atan(a*b*b/(2*x))))

Solution (Python):
import math

a,b,x= map(int, input().split())

if x<a*a*b/2:
    a2= x/(a*b/2)
    print(math.degrees(math.atan(b/a2)))
else:
    a3=(a*a*b-x)/(a*a/2)
    print(math.degrees(math.atan(a3/a)))

Solution (Python):
import math
a, b, x = map(int, input().split())




if x >= a**2 * b / 2:
    
    tan = 2 * (a**2 * b - x) / a**3
    ans = math.degrees(math.atan(tan))
    print(ans)


else:
    
    
    tan = (a * b**2) / (2 * x)
    ans = math.degrees(math.atan(tan))
    print(ans)

Solution (Python):

from math import degrees, atan

a, b, x = map(int, input().split())
bot = a * a * b
if x * 2 > bot:
    print(degrees(atan((bot - x) * 2 / a**3)))
else:
    print(degrees(atan(b**2 * a / (2 * x))))

Solution (Python):






import math





a,b,x = map(int, input().split())





theta = 0
if x >= a**2*b/2:
    tan = (2*(a*a*b-x))/(a**3)
    ans = math.degrees(math.atan(tan))
else:
    tan = (a*b*b)/(2*x)
    ans = math.degrees(math.atan(tan))
print(ans)

Solution (Python):
def binary_search(ok, ng, error, test):
    """
    :param ok: solve(x) = True を必ず満たす点
    :param ng: solve(x) = False を必ず満たす点
    """
    while abs(ok - ng) > error:
        mid = (ok + ng) / 2
        if test(mid):
            ok = mid
        else:
            ng = mid
    return ok

def max2(x,y):
    return x if x > y else y

def min2(x,y):
    return x if x < y else y

def test(y):
    return (a**3*tan(y)/2 + (b-a*tan(y))*cos(y)*a**2/cos(y) if b-a*tan(y) >= 0 else b**2*a*tan(pi/2-y)/2 ) >= x

from math import *
a, b, x = map(int, input().split())


print(binary_search(0,pi/2,10**(-8), test)*180/pi)

Solution (Python):
import math
a, b, x = list(map(float, input().split()))
if x <= 0.5 * a * a * b:
    res = math.degrees(math.atan(2 * x / (a * b * b)))
elif x < a * a * b:
    res = math.degrees(math.atan(a / (2 * (b - x / a ** 2))))
else:
    res = 90.0
print(f'{90 - res:.7f}')

Solution (Python):
import math
a,b,x = map(int,input().split())

y = math.atan((a*(b**2))/(2*x))

if b/math.tan(y) <= a:
    print(math.degrees(y))
    
else:
     print(math.degrees(math.atan(2*(a**2*b-x)/(a**3))))

Solution (Python):
import math
import sys
input = sys.stdin.readline


def main():
    a, b, x = map(int, input().split())
    x /= a
    h = x / a
    if h < b/2:
        t = 2 * x / b
        ans = math.degrees(math.atan(b/t))
    else:
        ans = math.degrees(math.atan(2*(b-h)/a))
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import math

A, B, X = map(int, input().split())
if A * A * B < 2 * X:
    print(math.degrees(math.atan(2 * B / A - 2 * X / A ** 3)))
else:
    print(math.degrees(math.atan(A * B * B / (2 * X))))

Solution (Python):

from math import radians, sin, cos, tan, degrees, atan
a, b, x = map(int, input().split())







if a * a * b / 2. <= x:
    ans = degrees(atan(2 * (a * a * b - x) / (a * a * a)))
else:
    ans = 90 - degrees(atan((2 * x) / (a * b * b)))
print(ans)

Solution (Python):
import math

a, b, x = map(int,input().split())
v = a*a*b

if x > v/2:
    y = 2*(b-(x/(a*a)))
    naname = math.sqrt((y*y) + (a*a))
    cosine = a/naname
    print(math.degrees(math.acos(cosine)))
elif x < v/2:
    y = 2*x/(b*a)
    naname = math.sqrt((y*y)+(b*b))
    cosine = b / naname
    print(90-math.degrees(math.acos(cosine)))
else:
    naname = math.sqrt((a*a)+(b*b))
    cosine = a/naname
    print(math.degrees(math.acos(cosine)))

Solution (Python):
import math
a,b,x = map(int,input().split())

t = False
volume = a*a*b
if x <= volume/2:
  t = True
  
if t:
  tan = a*(b**2)/(2*x)
else:
  tan = 2*((a**2)*b - x)/a**3
    
print(math.degrees(math.atan(tan)))

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


a,b,x = list(map(int, input().split()))
import math
if x*2>=a*a*b:
    the = (a*b - x/a) / (0.5*a*a)
else:
    the = (b*b*a) / (2*x)
ans = math.atan(the)
print(ans*180/math.pi)

Solution (Python):
import math
a,b,x = map(int,input().split())

t = False
volume = a*a*b
if x <= volume/2:
  t = True
  
if t:
  tan = a*(b**2)/(2*x)
else:
  tan = 2*((a**2)*b - x)/a**3
    
print(math.degrees(math.atan(tan)))

Solution (Python):
import math

a, b, x = map(int, input().split())

if pow(a,2) * b == x:
    print(0)
elif pow(a,2) * b / 2 <= x:
    print(90 - math.degrees(math.atan((a / 2) / (b - x / pow(a,2)))))
else:
    print(90 - math.degrees(math.atan((2 * x / (a * b)) / b)))

'''
left = 0
right = math.pi / 2
for i in range(10**5):
    mid = (left + right) / 2
    water = b * b * math.tan(math.pi / 2 - mid) * 0.5 * a
    if water > x:
        left = mid
    elif water < x:
        right = mid
    else: break
print(i, water, x)
print(math.degrees(mid))
'''

Solution (Python):
from math import *

a, b, x = map(int, input().split())

areatotal = a*a*b

if areatotal / 2 == x: print(45.0)
elif x > areatotal/2:
    left = 0.0
    right = 90.0
    while right-left > 0.00000001:
        current = (right+left)/2
        if a**2 * tan(radians(current)) / 2 * a < (areatotal - x):
            left = current
        else:
            right = current
    print(left)
else:
    left = 0.0
    right = 90.0
    while right-left > 0.00000001:
        current = (right+left)/2
        if b**2 * tan(radians(90-current))/2*a > x:
            left = current
        else:
            right = current
    print(left)

Solution (Python):
a,b,x=map(int,input().split())
import math

if x >= (a**2)*b/2:
    th = math.degrees(math.atan((a*b-x/a)*2/(a**2)))
else:
    th = math.degrees(math.atan((a*(b**2)/(2*x))))
print(th)

Solution (Python):
import math
a,b,x=map(int,input().split())
if 2*x>=a*a*b:
  y=a*a*b-x
  bb=(2*y)/(a*a)
  ans=math.degrees(math.atan(bb/a))
  
else:
  bb=2*x/(a*b)
  ans=math.degrees(math.atan(b/bb))
  
print(ans)

Solution (Python):
import math
a,b,x = map(int, input().split())
if x>=a**2*b/2:
    tan = (2*(a*a*b-x))/(a**3)
    ans = math.degrees(math.atan(tan))
else:
    tan = (a*b*b)/(2*x)
    ans = math.degrees(math.atan(tan))
print(ans)

Solution (Python):
def resolve():
    '''
    code here
    '''
    import math
    a, b, x = [int(item) for item in input().split()]

    s = x/a

    s_delta = a*b - s
    if s_delta <= a*b/2:
        print(math.degrees(math.atan((2* s_delta)/a**2)))
    else:
        print(math.degrees(math.atan(b**2/(2*s))))

if __name__ == "__main__":
    resolve()

Solution (Python):
import math
a,b,x = map(int,input().split())

menseki = a * a
V = menseki * b

if V <= 2 * x:
    ans = (2 * (V - x)) / (a ** 3)
    degree = math.degrees(math.atan(ans))
    print(degree)
else:
    ans = (a * b * b) / (2 * x)
    degree = math.degrees(math.atan(ans))
    print(degree)

Solution (Python):
import math
a,b,x=map(int, input().split())
if x/a >= a*b/2:
  print(math.degrees(math.atan(2*b/a-2*x/a**3)))
else:
  print(math.degrees(math.atan(a*b**2/x/2)))

Solution (Python):
from math import tan,radians
a,b,w=map(int,input().split())
V=a**2*b
def taiseki(x,a,b):
    x=90-x
    if tan(radians(x))>a/b:
        x=90-x
        return V-(a**3*tan(radians(x)))/2
    else:
        return a*b**2*tan(radians(x))/2
if V==w:
    print(0)
    exit()
ok,ng=0,90
while ng-ok>0.00000001:
    mid=(ok+ng)/2
    if taiseki(mid,a,b)>=w:
        ok=mid
    else:
        ng=mid
print(ng)

Solution (Python):
import math
def resolve():
    a, b, x = list(map(int, input().split()))
    if (a**2)*b/2 > x:
        print(90-math.degrees(math.atan(2*x/((b**2)*a))))
    else:
        if x == (a**2)*b:
            print(0)
        else:
            print(90-math.degrees(math.atan(a**3/(2*(a**2)*b-2*x))))
    

if '__main__' == __name__:
    resolve()

Solution (Python):
from math import atan, degrees
a, b, x = map(int, input().split())
vol = a**2*b/2
if x < vol:
    ans = atan((a*b**2)/(2*x))
elif x > vol:
    ans = atan((-2/a**3)*(x-a**2*b))
else:
    ans = atan(b/a)
print(degrees(ans))

Solution (Python):
a,b,x = map(int,input().split())
import math
if a*a*b<=2*x:
  print(math.degrees(math.atan(2*(a*a*b-x)/(a**3))))
else:
  print(math.degrees(math.atan(a*b*b/2/x)))

Solution (Python):
from math import atan
from math import degrees

a, b, x = [int(x) for x in input().split()]

volume = a * a * b
volume_per = x / volume

if volume_per >= 0.5:
    up = b * (1 - volume_per)
    down = a / 2
else:
    up = b
    down = 2 * a * volume_per

print(degrees(atan(up/down)))

Solution (Python):
from math import atan,pi

a,b,x=map(int,input().split())

if b-x/a**2 <= x/a**2:print(atan((b-x/a**2)/(a/2))*(180/pi))
else:
  y = x/a*2/b
  print(atan(b/y)*(180/pi))

Solution (Python):

import sys
from collections import deque, defaultdict
from math import sqrt, factorial, gcd, ceil, atan, pi



import string

from bisect import bisect_left
MOD = int(1e9)+7
INF = float('inf')


def solve():
    
    a, b, x = [int(x) for x in input().split()]
    y = x / a
    if y < a * b / 2:
        c = 2 * y / b
        print(atan(b/c)*180/pi)
    else:
        z = a * b - y
        c = 2 * z / a
        print(atan(c/a)*180/pi)


    


t = 1

for case in range(1,t+1):
    ans = solve()


"""

azyxwvutsrqponmlkjihgfedcb

"""

Solution (Python):
import math
a, b, x = map(int, input().split())
if x >= a**2 * b / 2:
    tan = (2 * (a ** 2 * b - x)) / a ** 3
else:
    tan = (a*b**2) / (2 * x)
print(math.atan(tan)/ math.pi * 180)

Solution (Python):
a, b, x=map(int, input().split())
if a*a*b==x:
  print(0)
  exit()
import math
if 2*x/(a*b)>=a:
  ans=a/(2*b-2*x/(a**2))
else:
  ans=2*x/(a*b**2)
print(90-math.degrees(math.atan(ans)))

Solution (Python):
import math
a,b,x=map(int,input().split())

if x>=a*a*b/2:
    ans=math.degrees(math.atan(2*(a*a*b-x)/(a*a*a)))
else:
    ans=math.degrees(math.pi/2-math.atan(2*x/(a*b*b)))

print(ans)

Solution (Python):
import math

a, b, x = map(int,input().split())
lb = 0
ub = 90

while ub - lb > 0.5 * 10**-6:
    theta = (lb+ub) / 2
    tt = math.tan(math.radians(theta))
    tt9 = math.tan(math.radians(90 - theta))
    
    if b * tt9 >= a:
        y = a*a*b - a * a*a*tt/2 - x
        if y < 0:
            ub = theta
        else:
            lb = theta
    else:
        y = a * b*b*tt9/2 - x
        if y < 0:
            ub = theta
        else:
            lb = theta
print(theta)

Solution (Python):
import math
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, x = map(int, readline().split())

vol = (a ** 2) * b

if vol / 2 >= x:
    tan = 2 * x / a / (b ** 2)
    rad = math.atan(tan)
    deg = math.degrees(rad)
    ans = 90-deg
    print(ans)
else:
    tan = 2 * (a * b - x / a) / a ** 2
    rad = math.atan(tan)
    deg = math.degrees(rad)
    print(deg)

Solution (Python):
import math
from fractions import Fraction
a,b,x=map(int,input().split())
if b*(a**2)<=x*2:
    print(math.degrees(math.atan(Fraction(2*(a*a*b-x),a**3))))
else:
    print(math.degrees(math.atan(Fraction(a*b*b,2*x))))

Solution (Python):
import math
a,b,x = map(int,input().split())
if x>=(a**2)*b/2:
  y = 2*b-2*x/(a**2)
  print(math.degrees(math.atan2(y,a)))
else:
  y = 2*x/(a*b)
  print(90-math.degrees(math.atan2(y,b)))