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 sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log, atan,pi 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    a,b,x = MI()
    x /= a
    if x > a*b/2:
        x = a*b-x
        y = 2*x/a
        ans = (atan(y/a)*1/(2*pi)*360)
        
    else:
        y = 2*x/b
        ans = 90 - (atan(y/b)*1/(2*pi)*360)
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):
import math

inputs = list(map(int, input().split()))
a = inputs[0]
b = inputs[1]
x = inputs[2]

l = a * a * b
d = x / l
if d <= 0.5:
  h = 2 * a * d
  atan = (math.degrees(math.atan(b/h)))
  print(round(atan, 6))
else:
  h = 2 * b * (1-d)
  atan = (math.degrees(math.atan(h/a)))
  print(round(atan, 6))

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

half = a*a*b/2

from math import atan,pi
if x <= half:
    c = 2*x/a/b
    ans = atan(c/b)
else:
    c = 2*x/a/a - b
    if abs(b-c) < 10**(-7):
        ans = pi / 2
    else: ans = atan(a/(b-c))
print(90-ans*180/pi)

Solution (Python):
import math

a, b, x = map(int, input().split())
if x / a >= a * b / 2:
    h = 2 * (b - x / a ** 2)
    r = math.atan2(h, a)
else:
    w = 2 * (x / (a * b))
    r = math.atan2(b, w)

print(180 * r / math.pi)

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

Solution (Python):
import math

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

def main(a,b,x):
    if ((a**2*b)-x) != 0:
        if x > a**2*b/2:
            y = (a ** 3)/(2*((a**2*b)-x))
            θ = math.atan(y)
            result = math.degrees(math.pi/2-θ)

        else:
            y = 2*x/(a*b**2)
            θ = math.atan(y)
            result = math.degrees(math.pi/2-θ)

        return result    
    else:
        return 0

print(main(a,b,x))

Solution (Python):
import math
a, b, x = map(int, input().split())
result = 0.0
if  a * b / 2 < x / a:
    h = 2 * (b - x / (a * a))
    result = math.degrees(math.atan2(h, a))
else:
    w = 2 * x / (a * b)
    result = math.degrees(math.atan2(b, w))
print(result)

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

Solution (Python):

import sys

from math import pi, atan2












def main():
    a, b, v = map(int, sys.stdin.readline().split())

    if v / a >= a * b / 2:
        ans = atan2(2 * (b - v / a ** 2), a) * 180 / pi 
    else:
        ans = atan2(a * b ** 2, 2 * v) * 180 / pi
    
    print(ans)

if __name__ == "__main__":
    main()

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

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

v0 = (a**2)*b
v1 = 0.5*(a**2)*b
ans = 0
if x >= v1:
    v = v0 - x
    ans = math.degrees(math.atan(2.0*v/(a**3)))
else:
    ans = math.degrees(math.atan(a*b*b/(2.0*x)))

print(ans)

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

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

Solution (Python):
from math import atan, degrees

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

Solution (Python):
import math

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

y = x / a

def solve_triangle(a, b, y):
    l = y / b * 2
    return math.atan(b / l) / math.pi * 180

def solve_trapezium(a, b, y):
    r = a * b - y
    l = r / a * 2
    return math.atan(l / a) / math.pi * 180

if a * b / 2 > y:
    print(solve_triangle(a, b, y))

else:
    print(solve_trapezium(a, b, y))

Solution (Python):
import math

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

in1 = 2*(a*b-x/a)/(a**2)
in2 = a*(b**2)/(2*x)

ans1 = math.degrees(math.atan(in1))
ans2 = math.degrees(math.atan(in2))

if x > (a**2)*b/2:
    ans = ans1
else:
    ans = ans2

print(ans)

Solution (Python):
import math
PI = math.pi
EPS = 0.0000000001

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

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


def solve():
    ok = PI / 2
    ng = 0.0
    for _ in range(100000):
        mid = (ok+ng) / 2
        if f(a, b, mid) < x:
            ok = mid
        else:
            ng = mid
    print(ok/PI*180)    

solve()

Solution (Python):
import math
PI = math.pi
EPS = 0.0000000001

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

def f(a, b, theta):
    if theta > PI / 2 - EPS:
        return 0.0
    ret = 0
    if a * math.tan(theta) <= b:
        return a * a * b - a * a * a * math.tan(theta) / 2
    else:
        return b * b / math.tan(theta) * a / 2


def solve():
    ok = PI / 2
    ng = 0.0
    for _ in range(100000):
        mid = (ok+ng) / 2
        if f(a, b, mid) < x:
            ok = mid
        else:
            ng = mid
    print(ok/PI*180)    

solve()

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

y=a*a*b-x

c=(2*y)/(a*a)

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

Solution (Python):
import math

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

tmp = a*a*b/2

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

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

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

import math

menseki = x/a
if menseki >= (a*b)/2:
    amari = a*b -menseki
    tan = amari * 2 / (a**2)
    
else:
    tan_90_theta = menseki * 2 / (b**2)
    tan = 1 / tan_90_theta
theta = math.degrees(math.atan(tan))
print(theta)

Solution (Python):
import numpy as np


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

    if a * a * b / 2.0 <= x:
        theta = np.arctan(2 * (a * a * b - x) / a**3)
    else:
        theta = np.pi / 2.0 - np.arctan(2 * x / (a * b * b))

    print(np.degrees(theta))


if __name__ == '__main__':
    main()

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

Solution (Python):
import math


class Solution:
    def solve(self, a: int, b: int, x: int) -> float:

        def vol(theta: float) -> float:
            t = math.tan(theta)

            if t > a/b:
                return (a**2)*b - (a**3)/2/t
            else:
                return a*(b**2)*t/2

        
        if abs(a*a*b - x) < 1e-8:
            return 0

        thetaLeft = 0
        thetaRight = math.pi/2 - 1e-8

        for i in range(100):
            thetaCenter = (thetaLeft + thetaRight)/2
            if vol(thetaCenter) < x:
                thetaLeft = thetaCenter
            else:
                thetaRight = thetaCenter

        return 90 - thetaLeft * 180 / math.pi


if __name__ == '__main__':

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

    
    solution = Solution()
    print(solution.solve(a, b, x))

Solution (Python):
import math

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

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

Solution (Python):
import math

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


Vc = a*a*b/2



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

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

    
    
print(math.degrees(theta))

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

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

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

Solution (Python):
a,b,x=map(int,input().split())
import math
ab=a*b
s=x/a
h=(ab-s)*2/a
if ab/2<=s:
    print(math.degrees(math.atan2(h,a)))
else:
    w=s*2/b
    print(math.degrees(math.atan2(b,w)))

Solution (Python):
import math

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

taiseki = a * a * b

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

Solution (Python):




def I(): return int(input())


def IsIl(): return list(map(lambda x: int(x), input().split()))


def InIl(n): return [input() for i in range(n)]


def IsIt(): return map(lambda x: int(x), input().split())


def InIl(n): return map(input() for i in range(n))


def SsSl(): return list(map(lambda x: x, input()))




def SSd():
    from collections import defaultdict
    A = input() 
    dd=defaultdict(int)
    for a in A:
        dd[a]+=1
    return dd

import math

a,b,x=IsIt()

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

Solution (Python):
import math

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

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

print(ans)

Solution (Python):
from sys import stdin
import math
a, b, x = [int(x) for x in stdin.readline().rstrip().split()]

box = a*a*b
air = box-x
if air * 2 > box:
    
    h = 2*x/b/a
    l = (h**2 + b**2)**0.5
    degree = math.degrees(math.acos(h/l))
else:
    
    hight = air/a/a*2
    l = (a**2 + hight**2)**0.5
    degree = math.degrees(math.acos(a/l))

print(degree)

Solution (Python):
import math

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

area_base = a ** 2
volum_bottle = area_base * b

k = (2 * (volum_bottle - x)) / a ** 2

if k <= b:
  K_t = k / a
  angle = math.degrees(math.atan(K_t))
else:
  L_t = a * (b ** 2) / (2 * x)
  angle = math.degrees(math.atan(L_t))
  
print(round(angle, 10))

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

T = a * b / 2 * a

if T >= x:
    na = 2 * x / b / a
    rad = math.atan(b/na)
    deg = math.degrees(rad)
    print(deg)
else:
    b2 = x * 2 / a / a - b
    rad = math.atan((b-b2)/a)
    deg = math.degrees(rad) 
    print(deg)

Solution (Python):
import numpy as np
def solve(a, b, x):
    if a < b:
        if x < a*a*b/2:
            h = 2*x / (a*b)
            theta = np.arctan(b/h)
        else:
            h = 2*(a*a*b - x) / (a*a)
            theta = np.arctan(h/a)
    else:
        if x < a*a*b/2:
            h = 2*x / (a*b)
            theta = np.arctan(b/h)
        else:
            h = 2*(a*a*b - x) / (a*a)
            theta = np.arctan(h/a)
    return theta / np.pi * 180

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

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

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

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

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

print(theta)

Solution (Python):
import math
a,b,x=list(map(int,input().split()))
maxv=a*a*b
sukima=maxv-x
teimenseki=sukima/a
y=teimenseki*2/a
 
if x > (maxv/2):
    print(math.degrees(math.atan(y/a)))
else:
    tei=x/a
    z=tei*2/b
    print(math.degrees(math.atan(b/z)))

Solution (Python):
import math

if __name__ == "__main__":
    li = list(map(int,input().split()))
    a=li[0]
    b=li[1]
    x=li[2]

    s=x/a

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

Solution (Python):
import math
input01 = input()
a=input01.split()

tate=float(a[0])
takasa=float(a[1])
mizu=float(a[2])
menseki1 = tate * takasa
menseki2 = mizu / tate
diff=menseki1-menseki2
rad=0
if(diff <= tate*takasa/2):
    stakasa=2*diff/(tate)
    rad = math.degrees(math.atan(stakasa/tate))
elif(diff > tate*takasa/2):
    stakasa=2*(menseki1-diff)/(takasa)
    rad = math.degrees(math.atan2(takasa,stakasa)) 
    

print(rad)

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

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

Solution (Python):
import numpy as np
a, b, x = map(float, input().split())
V = a**2 * b
if V/2 >= x:
    rad = np.arctan(a*b**2/2/x)
else:
    rad = np.arctan(2*(V-x)/a**3)
print(np.rad2deg(rad))

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


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

Solution (Python):
import numpy as np
a, b, x = map(int, input().split())
if x <= a*a*b/2:
    print(np.arctan(a*b*b/(2*x))*180/np.pi)
else:
    print(np.arctan((a*a*b - x)/(a*a*a/2))*180/np.pi)

Solution (Python):
import sys
import math

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

if a*a*b/2 <= x:
	T=a*(b-(x/(a*a)))
	c=2*T/a 
	d = math.atan2(c, a)
	d_deg=math.degrees(d)
else:
	e=2*x/(a*b)
	d = math.atan2(b, e)
	d_deg=math.degrees(d)
	

print(d_deg)

Solution (Python):
import math

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

cap = a ** 2 * b

if x == cap / 2:
    s = 45
elif x < cap / 2:
    t = 2 * x / (a * b ** 2)
    s = 90 - math.degrees(math.atan(t))
else:
    q = cap - x
    t = 2 * q / (a ** 3)
    s = math.degrees(math.atan(t))
    
print(float(s))

Solution (Python):
import math

a,b,x = (int(num) for num in input().split())
suf2 = a*b
vol = a*a*b
if (vol/2)>=x:
    l1 = x*2 / suf2
    x = float(b)/l1
    ans = math.degrees(math.atan(x))
else:
    l2 = (vol-x)*2 / (a*a)
    x = l2/float(a)
    ans = math.degrees(math.atan(x))
    
print(round(ans,6))

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

Solution (Python):
import math
nums = [int(e) for e in input().split()]
a = nums[0]
b = nums[1]
x = nums[2]
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):
import math

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

Solution (Python):
import math
list = input().split()

a = int(list[0])
b = int(list[1])
x = int(list[2])

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

print(ans)

Solution (Python):
import numpy as np

a,b,x = map(int, open(0).read().split())
if a*a*b/2 >= x:
  theta = np.rad2deg(np.arctan(a*b*b/2/x))
else:
  theta = np.rad2deg(np.arctan(2*(a*b-x/a)/a/a))
print(theta)

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

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

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

Solution (Python):
import math
a,b,x=(int(x) for x in 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*a*b-x)/a/a/a)*180/math.pi)

Solution (Python):
import math

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

if a * a * b == x:
    print(0)
    exit(0)

if x * 2 <= a * a * b:
    P = (2 * x) / (a * b)
    Q = b
else:
    P = a
    Q = (2 * (a * a * b - x)) / (a * a)

R = math.sqrt(P * P + Q * Q)
cosp = (Q * Q + R * R - P * P) / (2 * Q * R)
print(90 - math.degrees(math.acos(cosp)))

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

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

Solution (Python):
import numpy as np

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

if x <= a * a * b / 2:
    a_ = 2 * x / a / b
    r = (a_**2 + b**2)**0.5
    theta = np.arcsin(b / r)
else:
    b_ = 2 * (a**2 * b - x) / a**2
    r = (a**2 + b_**2)**0.5
    theta = np.arcsin(b_ / r)

print(np.degrees(theta))

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

Solution (Python):

import math

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

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

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

Solution (Python):
import math

nums = [int(e) for e in input().split()]

if nums[2] >= ((nums[0]**2 * nums[1]) / 2):
    a = 2*((nums[0]**2 * nums[1]) - nums[2]) / nums[0]**3
    print(math.degrees(math.atan(a)))

else:
    a = (nums[0] * nums[1]**2) / (2 * nums[2])
    print(math.degrees(math.atan(a)))

Solution (Python):
import math

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


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

print(math.degrees(ans))

Solution (Python):
import math

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

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

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-x/a**3))))
else:
    print(90.0-math.degrees(math.atan((2*x)/(a*b*b))))

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

h = ((x/a)/b)*2
w = b
r = math.sqrt(h*h + w*w)

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

Solution (Python):






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

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

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

print(ans)

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math

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

def over_flag(a,b,x):
    return math.atan( 2*b/a-2*x/a**3 )*180/math.pi
 
def below_flag(a,b,x):
    return 90-math.atan(2*x/(a*b**2))/math.pi*180

def main(a,b,x):
    if x>a**2*b:
        print(0)
        return 0
    if x>a**2*b/2:
        print(over_flag(a,b,x))
    else:
        print(below_flag(a,b,x))
    return 0
main(a,b,x)

Solution (Python):
def main():
  a, b, c = map(int, input().rstrip("\n").split(" "))

  import math

  container_size = (a * a * b)
  if c <= container_size / 2:
    height = a * (c / (container_size / 2))
    angle = math.degrees(math.atan(height / b))
  else:
    empty_space = container_size - c
    width = b * (empty_space / (container_size / 2) )
    
    angle = 90 - math.degrees(math.atan(width / a))

  print(90 - angle)

if __name__ == '__main__':
  main()

Solution (Python):
import numpy as np

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

V = a**2 * b
if 0 <= x < V / 2:
    c = x / a / b * 2
    rad = np.arctan(b / c)
elif V / 2 <= x <= V:
    c = (V - x) / a**2 * 2
    rad = np.arctan(c / a)
deg = rad * (180 / np.pi)
print(deg)

Solution (Python):
import math
s = input().split()
a = int(s[0])
b = int(s[1])
x = int(s[2])
if x < a**2*b/2:
    deg = math.degrees(math.atan2(a*b**2, 2*x))
else:
    deg = math.degrees(math.atan2(2*a**2*b-2*x, a**3))
print(deg)

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

Solution (Python):
import math

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

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

elif x < 0.5*a*a*b:
    y = 2*x/a/b
    tan = b/y
    ans = math.atan(tan)
    print(math.degrees(ans))

else:
    print("45.0000000000")

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

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

if x >= v/2:
  c =  2*(v-x)/(a**2)
  print(m.degrees(m.atan(c/a)))
else:
  c =  2*x/(a*b)
  print(m.degrees(m.atan(b/c)))

Solution (Python):
import math

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import time
st_time=time.time()

from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import random
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
ts=time.time()
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
show_flg=False
show_flg=True


a,b,x=LI()
if x<a*a*b/2:
    t=a*b*b/2/x
    ans=math.atan(t)/math.pi*180
else:
    t=2*b/a-2*x/(a**3)
    ans=math.atan(t)/math.pi*180

print(ans)

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

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

Solution (Python):
mi = lambda : map(int, input().split())

import math

a, b, x = mi()

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

print(ans)

Solution (Python):
import math
N=list(map(int,input().split()))



if N[2]<=N[0]**2*N[1]/2:   
 a=N[1]
 b=N[2]/N[0]/N[1]*2
 print(90-math.degrees(math.atan(b/a)))
else: 
 c=N[0]**2*N[1]-N[2]
 a=N[1]
 b=c/N[0]/N[0]*2

 print(math.degrees(math.atan(b/N[0])))

Solution (Python):
import math

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

a2 = 2 * x / (a * b)

if a2 <= a:
    ans = math.atan(b / a2) * 360 / (2 * math.pi)

else:
    y = (a * a * b) - x
    b2 = 2* y / (a * a)
    ans = math.atan(b2 /a) * 360 / (2 * math.pi)

print(ans)

Solution (Python):
import numpy as np

def f(a, b, x):
    v = a**2*b
    if x >= v/2:
        return np.rad2deg(np.arctan((v-x)*2/a**3))
    else:
        return np.rad2deg(np.arctan((a*b**2/(x*2))))

x = map(int, input().split())
print(f(*x))

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

if x >= a**2*b/2:
    print(degrees(np.arctan((2*b/a-2*x/a**3))))
else:
    print(90-degrees(np.arctan(2*x/(a*b**2))))

Solution (Python):
import math

def main():
    X = input().split(' ')
    a = int(X[0])
    b = int(X[1])
    x = int(X[2])

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

if __name__ == "__main__":
    main()

Solution (Python):
import math

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

Solution (Python):
import math


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


def calc_tan_theta(a, b, x):
    mass = a * a * b
    if x >= mass / 2:
        return 2 * (b - x / (a * a)) / a
    else:
        return 0.5 * a * b * b / x


def main():
    a, b, x = get_input()
    tan_theta = calc_tan_theta(a, b, x)
    degree = math.degrees(math.atan(tan_theta))
    print(degree)


main()

Solution (Python):
from math import tan, radians, pi

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

def solve(angle):
    c = A*tan(radians(angle))
    if c <= B:
        max_water = A*B - (A*c/2)
    else:
        d = B*tan(radians(90-angle))
        max_water = B*d/2
    return max_water >= X/A

ok = 0
ng = 90
for i in range(30):
    mid = (ok+ng)/2
    
    if solve(mid):
        ok = mid
    else:
        ng = mid
    

print(ok)

Solution (Python):
from math import tan, radians, pi

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

def angle_to_max_water(angle):
    c = A*tan(radians(angle))
    if c <= B:
        return A*B - (A*c/2)
    else:
        d = B*tan(radians(90-angle))
        
        return B*d/2

l, r = 0, 90
for i in range(30):
    mid = (l+r)/2
    
    if angle_to_max_water(mid) <= X/A:
        r = mid
    else:
        l = mid
    

print(r)

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

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

if x/a >= a*b / 2:
    t_theta = 2*(a*b - x/a) / (a*a)
    theta = degrees(atan(t_theta))
else:
    t_theta = 2 * x / (a * b**2)
    theta = degrees(atan(1 / t_theta))

print(theta)

Solution (Python):
from math import atan, degrees

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

print(ans)

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