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):
import numpy as np

'''実はarctanは実装されていた...
def search_arctan(tan):
    low = 0
    high = np.radians(90)
    while (high-low>=10**(-12)):
        mid = (low+high)/2 
        if np.tan(mid)<=tan:
            low = mid
        else:
            high = mid
    return np.rad2deg(mid)
'''
a,b,x = list(map(int,input().split()))


l = x/(a*a)

if l<=b/2.0:
    ans = np.rad2deg(np.arctan(b**2.0/(2.0*a*l)))
else:
    ans = np.rad2deg(np.arctan(2.0*(b-l)/a))

print(ans)

Solution (Python):
import numpy as np

def search_arctan(tan):
    low = 0
    high = np.radians(90)
    while (high-low>=10**(-12)):
        mid = (low+high)/2 
        if np.tan(mid)<=tan:
            low = mid
        else:
            high = mid
    return np.rad2deg(mid)

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

l = x/(a*a)

if l<=b/2.0:
    ans = search_arctan(b**2.0/(2.0*a*l))
else:
    ans = search_arctan(2.0*(b-l)/a)

print(ans)

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

Solution (Python):
import math

def run():
  a, b, x = map(int, input().split())
  if a**2*b/2 > x:
    tan = 2*x/(a*b**2)
    print(90-math.degrees(math.atan(tan)))
  else:
    tan = 2*(a**2*b-x)/(a**3)
    print(math.degrees(math.atan(tan)))
  
if __name__ == '__main__':
  run()

Solution (Python):

import sys
import math


def solve(a: int, b: int, x: int):
    h = 2 * (b - (x / (a*a)))
    if b < h:
        h = b
        a = 2 * (x / (a*b))
    print(math.degrees(math.atan(h / a)))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    x = int(next(tokens))  
    solve(a, b, x)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

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

    xdash = x / a
    FULL = a * b

    if xdash == FULL:
        return 0
    elif FULL / 2 == xdash:
        return b/a
    elif FULL / 2 > xdash:
        return b*b/xdash/2
    else:
        return 2*(a*b-xdash)/a/a

print(math.degrees(math.atan(h())))

Solution (Python):
import math

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

xdash = x / a
FULL = a * b

if xdash == FULL:
    print(0)
elif FULL / 2 == xdash:
    print(math.degrees(math.atan2(b,a)))
elif FULL / 2 > xdash:
    print(90-math.degrees(math.atan(2*xdash/b/b)))
else:
    print(90-math.degrees(math.atan(a*a/2/(a*b-xdash))))

Solution (Python):

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

print(degrees(ans))

Solution (Python):
a,b,x = map(int,input().split())
tal1 = (b-x/(a**2))*2/a
tal2 = a*(b**2)/2/x
tal = b/a
ans = tal1
if tal1>tal:
  ans = tal2
import math
ans = math.degrees(math.atan(ans))

print(ans)

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


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

if x >= (a ** 2) * b / 2:
    t = 2 / (a ** 3) * (b * a ** 2 - x)
    theta = atan(t)
else:
    theta = pi / 2 - atan((2 * x) / (a * b ** 2))

print(degrees(theta))

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

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

Solution (Python):
import math
s = input().split()
a = int(s[0])
b = int(s[1])
x = int(s[2])

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

Solution (Python):
import math
a, b, x = map(int, input().split())
h = x / (a ** 2)
r = math.atan((b - h) * 2 / a)
if h < a / 2 * math.tan(r):
    r = math.atan(b ** 2 * a / 2 / x)
print("{:.10f}".format(math.degrees(r)))

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

def f(a,b,x):
    theta = 0
    v = a * a * b / 2
    if x <= v:
        theta = math.degrees(math.atan((a * b * b / 2)/x))
        print(theta)
    else:
        theta = math.degrees(math.atan((2 * b -(2 * x /(a * a))) / a))
        print(theta)

f(a,b,x)

Solution (Python):
import math

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

h = x/a

if h >= b/2:
    d = math.atan(2*(b-h)/a)
    ans = math.degrees(d)

else:
    d = math.atan(2*x/b/b)
    ans = 90-math.degrees(d)

print(ans)

Solution (Python):
import math

def main():
    a, b, x = list(map(int, input().split()))

    if (x / a) > (a * b) / 2:
        h = (2/a) * ((a*b) - (x/a))
        r = math.atan2(h, a)
    else:
        area = x / a
        h = (2 * area) / b
        r = math.atan2(b, h)

    ans = r * 180 / math.pi
    print(ans)



if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
import itertools
import bisect
import math
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

a, b, x = na()
d = x / (a * a)
if 2 * d < b:
    angle = math.atan(b / (2 * a * d / b)) * (180 / math.pi)
else:
    angle = math.atan(2 * (b - d) / a) * (180 / math.pi)
if angle < 0:
    angle += 180
if angle > 180:
    angle -= 180
print(angle)

Solution (Python):
import sys
from math import atan, degrees, pi

[astr, bstr, cstr] = sys.stdin.readline().split(" ")
a = float(astr)
b = float(bstr)
x = float(cstr)

theta = float(0)
threshold = a * a * b / 2

if threshold < x:  
    theta = (2 * (a * a * b - x)) / (a*a*a)
else:
    theta = (a * b * b) / x / 2

rad = atan(theta)
print(degrees(rad))

Solution (Python):
data = [int(x) for x in input().split()]
a = data[0]
b = data[1]
x = data[2]
v = a*a*b
import math
if x <= v/2:
  tan = 2*x/(a*b*b)
  w = math.atan(tan)
  t = 90 - math.degrees(w)
else:
  y = v - x
  tan = 2*y/(a*a*a)
  w = math.atan(tan)
  t = math.degrees(w)
print(t)

Solution (Python):
from math import atan2, pi

a, b, x = map(int, input().split())
V = a * a * b
p2t = 180 / pi
if V == x:
    print(0)
elif V/2 < x:
    
    print(90-p2t*atan2(a, 2*(V-x)/a**2))
else:
    
    print(90-p2t*atan2(2*x/a/b, b))

Solution (Python):
import math


def calc(a, b, theta):
    if a * math.tan(math.radians(theta)) <= b:
        return a * a * b - a * a * a * math.tan(math.radians(theta)) / 2
    else:
        return b * b / math.tan(math.radians(theta)) * a / 2


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

    ok = 90
    ng = 0
    for _ in range(1000):
        mid = (ok + ng) / 2
        if calc(a, b, mid) < x:
            ok = mid
        else:
            ng = mid

    print(ok)


if __name__ == '__main__':
    solve()

Solution (Python):
import math

EPS = 0.0000000001


def calc(a, b, theta):
    if a * math.tan(math.radians(theta)) <= b:
        return a * a * b - a * a * a * math.tan(math.radians(theta)) / 2
    else:
        return b * b / math.tan(math.radians(theta)) * a / 2


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

    ok = 90
    ng = 0
    for _ in range(1000):
        mid = (ok + ng) / 2
        if calc(a, b, mid) < x:
            ok = mid
        else:
            ng = mid

    print(ok)


if __name__ == '__main__':
    solve()

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

Solution (Python):
import math

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


if __name__ == '__main__':
    main()

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 = 2*S/b
    rad = math.atan2(b,w)
deg = rad/(2*math.pi)*360
print(deg)

Solution (Python):

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

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

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(math.degrees(rad))

Solution (Python):
from math import tan, pi

a, b, x = list(map(float, input().split()))
eps = 1e-9

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

def solve():
    ok = pi / 2.0
    ng = 0.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))

solve()

Solution (Python):
import math

def calc(a,b,deg): 
    
    rad = math.radians(deg)
    
    
    

    
    
    

    
    
    
    

    if b*math.tan(math.pi/2-rad) <= a:
        total_area = (b*math.tan(math.pi/2-rad)*b*1/2)
    if b*math.tan(math.pi/2-rad)>a:
        total_area = (a*b - a*math.tan(rad)*a*1/2)       

    return total_area * a

import bisect
def main():
    a, b, x = list(map(int, input().split()))

    left = 0
    right = 90
    deg = 45
    while True:
        y = calc(a, b, deg)
        if y - x >= -10 ** -7 and y - x <= 0:
            break
        if y > x:
            deg, left = (right+deg)/2, deg
        elif y < x:
            deg, right = (left+deg)/2, deg
    print(deg)

if __name__ == "__main__":
    main()

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

if x<a**2*b/2:
    theta=np.arctan2(a*b**2,2*x)
else:
    theta=np.arctan2(2*b-2*x/a**2,a)

print(math.degrees(theta))

Solution (Python):
from math import tan, radians

def water(a, b, t):
    if a * tan(radians(t)) < b:
        water = a*a*b - a*a*a*tan(radians(t))*0.5
        
    else:
        water = 0.5 * b * b*tan(radians(90 - t)) * a
    
    return water    


def main():
    a, b, x = map(int, input().split())
    min = 0
    max = 90
    for _ in range(10000):
        tmp = (min + max) / 2
        if water(a, b, tmp) < x:
            max = tmp
        else:
            min = tmp
    print(min)

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import math

a, b, x = map(int, input().split())
V = a * a * b
ta = 0.0
if x > V / 2.0:
    ta = 2.0 * (V - x) / (a ** 3)
else:
    ta = b * b * a / (2.0 * x)

print(math.degrees(math.atan(ta)))

Solution (Python):
def main():
    import math
    a, b ,x = [int(x) for x in input().split()]

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

    else:
        theta = math.atan(a*b*b/2/x)

    print(math.degrees(theta))

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    a, b, x = [int(x) for x in input().split()]

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

Solution (Python):
import math


def f(a: float, b: float, theta: float) -> float:
    
    
    
    if theta > (90.0 - 0.0000000001):
        return 0.0
    t = b * math.tan(math.radians(90.0 - theta))
    if t <= a:
        return b * t / 2
    else:
        top = b - (a * math.tan(math.radians(theta)))
        return (b + top) * a / 2


def water_bottle(a: int, b: int, x: int) -> float:
    ok = 90.0
    ng = 0.0
    water = x / a
    for _ in range(10000):
        mid = (ok + ng) / 2.0
        if f(a, b, mid) < water:
            ok = mid
        else:
            ng = mid
    return ok


if __name__ == '__main__':
    abx = list(map(int, input().split()))
    result = water_bottle(abx[0], abx[1], abx[2])
    print(result)

Solution (Python):
from math import atan2,pi

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

if a*b == S:
    ans = 0
elif S <= a*b/2:
    a = S/(b/2)
    ans = atan2(b,a)*180/pi
else:
    S = a*b-S
    a,b = b,a
    a = S/(b/2)
    ans = 90-atan2(b,a)*180/pi
print(ans)

Solution (Python):
from math import atan2,pi

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

if a*b == S:
    ans = 0
elif S <= a*b/2:
    a = S/(b/2)
    ans = atan2(b,a)*180/pi
else:
    bu = 2*S/a-b
    b = b-bu
    S -= a*bu
    ans = atan2(b,a)*180/pi
print(ans)

Solution (Python):
import math as m

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

Solution (Python):
import math 
a, b, x = map(int, input().split())
s = x / a
flg = 0
if s == a * b / 2:
    print(45.0)
    exit()
elif s > a * b / 2:
    flg = 1
else:
    flg = -1
if flg == -1:
    print(math.atan(b ** 2 /(2 * s)) / (2 * math.pi) * 360)
else:
    print(math.atan(2 / a ** 2 * (a * b - s)) / (2 * math.pi) * 360)

Solution (Python):

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

Solution (Python):
import math


def solve(a: int, b: int, x: int) -> float:
  if 2*x <= a**2 * b:
    return math.degrees(math.atan(a * b**2 / (2*x)))
  else:
    return math.degrees(math.atan( (2*b - 2*x/a**2) / a))


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

print(solve(a, b, x))

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

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

print(math.degrees(rad))

Solution (Python):
import math

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

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

Solution (Python):
import math
a,b,x=map(int,input().split())
cap=a**2*b
y=((cap-x)*2)/a**2

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a, b = LI()
    def c(x):
        return 1 <= x <= 9
    if c(a) and c(b):
        print(a * b)
        return
    print(-1)
    return


def B():
    a = set()
    for i in range(10):
        for k in range(10):
            a.add(i * k)
    x = II()
    if x in a:
        print("Yes")
    else:
        print("No")
    return


def C():
    n = II()
    factlize = []
    ans = inf
    for i in range(1, int(sqrt(n)) + 1):
        if n % i == 0:
            ans = min(ans, n // i + i - 2)
    print(ans)
    return


def D():
    a, b, x = LI()
    from math import atan, pi
    if a * a * b / 2 <= x:
        print(atan(2 * (a * a * b - x) / (a * a * a)) * 180 / pi)
    else:
        print((pi / 2 - atan(2 * x / (a * b * b))) * 180 / pi)
    return


def E():
    def solve(m):
        a1 = a[::-1]
        f1 = f[::1]
        res = 0
        for i in range(n):
            if a1[i] * f1[i] <= m:
                continue
            k = m // f1[i]
            res += a1[i] - k
            if res > K:
                return False
        return True

    n, K = LI()
    a = LI()
    a.sort()
    f = LI()
    f.sort()
    ok = max(a) * max(f)
    ng = -1
    while ok - ng > 1:
        mid = (ok + ng) // 2
        if solve(mid):
            ok = mid
        else:
            ng = mid
    print(ok)
    return


def F():
    return



if __name__ == '__main__':
    D()

Solution (Python):
from math import atan, degrees

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

if x >= ((a ** 2) * b) / 2:
    theta = (2 * ((a ** 2) * b - x) / (a ** 3))
else:
    theta = ((a * (b ** 2)) / (2 * x))

print(degrees(atan(theta)))

Solution (Python):
import math

def calcAgree(n):
    [a,b,x] = n

    if a*a*b/2 >= x :
        
        length1 = x/a/b*2
        length2 = (b**2+length1**2)**0.5

        target_angle = math.acos(length1/length2)
        
        return target_angle / (2*math.pi) * 360
    else:
        air_taiseki = a*a*b-x
        
        length1 = air_taiseki/a/a*2
        length2 = (a**2+length1**2)**0.5
        target_angle = math.asin(length1/length2)
        
        return target_angle / (2*math.pi) * 360

input_data = [int(x) for x in input().split()]

print(calcAgree(input_data))

Solution (Python):
import  math

a = 3.0
b = 1.0
x = 8.0

inp = input().split()
a = int(inp[0])
b = int(inp[1])
x = int(inp[2])

if a*a*b/2 >= x:
    A = 2.0*x/(b*a)
    print(math.atan2(b, A)*180/math.pi)
else:
    x = a*a*b - x
    B = 2.0*x/(a*a)
    print(math.atan2(B, a)*180/math.pi)

Solution (Python):
from math import atan, pi

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

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

Solution (Python):
import math

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

Solution (Python):
import numpy as np

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

if x > a * a * b / 2:
    tantheta = (2 * b * a**2 - 2 * x) / (a**3)
else:
    tantheta = a * b**2 / (2 * x)
costheta = 1 / np.sqrt(1 + tantheta**2)
print(np.arccos(costheta) * 180 / np.pi)

Solution (Python):
import math

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

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

print(ans)

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

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

a, b, x = map(int, input().split())
s1 = degrees(atan(2*b/a - 2*x/(a*a*a)))
s2 = 90 - degrees(atan(2 * x / (a * b * b)))

if(a*a*b/2 <= x):
    print(s1)
else:
    print(s2)

Solution (Python):
import math

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

if a * a * b / 2 <= x:
    p = 2 * x / (a ** 2) - b
    tanx = (b - p) / a
else:
    p = a - 2 * x / a / b
    tanx = b / (a - p)

print(math.degrees(math.atan(tanx)))

Solution (Python):
import math

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

if x > V / 2:
    theta = 180*math.atan(2*(V - x)/a**3)/math.pi
else:
    theta = 180*math.atan(a*b*b/2/x)/math.pi
print(theta)

Solution (Python):
import math

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

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

Solution (Python):
a,b,x=map(int,input().split())
import math
pii=math.pi
if x<=(a*a*b)/2:
    y=2*x/(b*a)
    tantheta=b/y
    ans=math.atan(tantheta)*(360/(2*pii))
    print(ans)
else:
    x=a*a*b-x
    
    y=(2*x/(a*a))
    tantheta=y/a
    ans=math.atan(tantheta)*(360/(2*pii))
    print(ans)

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

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

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















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

Solution (Python):


import math

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

V = a**2 * b
V_2 = V / a

x_2 = x / a

if x_2 > V_2/2:
    c = 2*x/a**2 - b
    theta = math.atan2(a,(b-c))
    deg = math.degrees(theta)
else:
    c = 2*x/(a*b)
    theta = math.atan2(c,b)
    deg = math.degrees(theta)

print("{}".format(90.0-deg))

Solution (Python):
a, b, x = map(int, input().split())
import math
h = x / (a * a)
if h > b / 2:
    w = a / 2
    ans = math.atan2(b - h, w) * 180 / math.pi
else:
    area = h * a
    w = 2 * area / b
    ans = math.atan2(b, w) * 180 / math.pi
print(ans)

Solution (Python):
import numpy as np

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

bottom = 2 * x / a**2 - b

if bottom == b:
    print(0)

else:    
    if bottom > 0:
        tan =  a / (b -  bottom)

    else:
        bottom = 2 / (a * b) * x
        tan = bottom / b

    theta = np.arctan(tan)
    ret = 90 - np.rad2deg(theta)

    print(ret)

Solution (Python):


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

if a*a*b==2*x:
    print(45)
    exit()

x/=a

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

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

print(math.degrees(math.atan(tan)))

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


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

print(math.degrees(math.atan(v)))

Solution (Python):

from math import tan, pi
eps = 10**(-9)

def binary_search(a, b, x):
    l = pi / 2
    r = 0.0
    if x <= a ** 2 * b / 2:
        while l - r > eps:
            mid = (r + l) / 2
            if a * b**2 / tan(mid) / 2 == x:
                return x
            elif a * b**2 / tan(mid) / 2 > x:
                r = mid
            else:
                l = mid
        return l
        
    else:
        while l - r > eps:
            mid = (r + l) / 2
            if a**2 * b - a**3 * tan(mid) / 2 == x:
                return x
            elif a**2 * b - a**3 * tan(mid) / 2 > x:
                r = mid
            else:
                l = mid
        return l

a, b, x = map(int, input().split())
print("{:.10f}".format(binary_search(a, b, x) * 180 / pi))

Solution (Python):

from math import tan, pi
eps = 10**(-12)

def binary_search(a, b, x):
    l = pi / 2
    r = 0.0
    if x <= a ** 2 * b / 2:
        while l - r > eps:
            mid = (r + l) / 2
            if a * b**2 / tan(mid) / 2 == x:
                return x
            elif a * b**2 / tan(mid) / 2 > x:
                r = mid
            else:
                l = mid
        return l
        
    else:
        while l - r > eps:
            mid = (r + l) / 2
            if a**2 * b - a**3 * tan(mid) / 2 == x:
                return x
            elif a**2 * b - a**3 * tan(mid) / 2 > x:
                r = mid
            else:
                l = mid
        return l

a, b, x = map(int, input().split())
print("{:.10f}".format(binary_search(a, b, x) * 180 / pi))

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


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

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


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

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

S = x/a
if S >= a*b/2:
    h = 2 * (a * b - S) / a
    print(math.degrees(math.atan2(h, a)))
else:
    w = 2 * S / b
    print(math.degrees(math.atan2(b, w)))

Solution (Python):
import math
a,b,x=map(int,input().split())
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):
import math
a, b, x = map(int, input().split())
tan_val1 = (2 * (a * a * b - x)) / (a*a*a)
tan_val2 = (a*b*b) / (2*x)
vol = (a*a*b)*0.5
if x > vol:
    ans = math.degrees(math.atan(tan_val1))
else:
    ans = math.degrees(math.atan(tan_val2))
print(ans)

Solution (Python):
from math import asin, degrees, sqrt
 
a,b,x = map(int,input().split())
 
m = 2*x/a**2 - b
if m >= 0:
    sin = (b-m)/sqrt((b-m)**2+a**2)
    print("{:.10f}".format(degrees(asin(sin))))
else:
    sin = b/sqrt((b**2)+((2*x)/(a*b))**2)
    print("{:.10f}".format(degrees(asin(sin))))

Solution (Python):
import math
str = input().split()
a = int(str[0])
b = int(str[1])
x = int(str[2])
if x > float(a*a*b)/2:
    print(math.degrees(math.atan(float(a*a*b-x)*2/a/a/a)))
else:
    print(math.degrees(math.atan(float(a*b*b)/x /2)))

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

Solution (Python):
import math 

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

Solution (Python):
import math

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

if x >= a*a*b*(1/2):
    air = a*a*b - x
    h = air / a / a * 2
    print(math.degrees(math.atan(h/a)))

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

Solution (Python):
import math

a, b, x = input().split(' ')
a, b, x = float(a), float(b), float(x)

full = a ** 2 * b
ratio = x / full



if ratio <= 0.5:
    
    s = (x / a)

    c = s * 2 / b
    
    

    print(
        90 - math.atan(c/b) * 180 / math.pi
    )
else:
    
    s = a*b - (x/a)
    c = s * 2 / a

    
    

    print(
        math.atan(c / a) * 180 / math.pi
    )

Solution (Python):
import math

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

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

Solution (Python):

import math
import heapq

MOD = 10**9+7

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

V = (a**2)*b

if x>=(V/2):
    h = 2*b-2*x/(a*a)
    htan = h/a
else:
    h = 2*x/(a*b)
    htan = b/h

ans = math.atan(htan)*180/(math.atan(1.0)*4)
print(ans)

Solution (Python):
import math
l , h , V = map(int,input().split())

h_0 = V / (l * l)

if h_0 >= h/2:
  theta_r = math.atan((h-h_0)/(0.5 * l))
  theta = 180 * theta_r / math.pi
  print(theta)
else:
  x = 2 * V / (l * h)
  theta_r = math.atan(x / h)
  theta = 90- (180 * theta_r / math.pi)
  print(theta)

Solution (Python):
import math

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

h = x / a**2.0

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

print(math.degrees(theta))