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
import math
a, b, x = map(int, input().split())

org_volume = a ** 2 * b
if x < org_volume / 2:
    y = (2 * x) / (a * b)
    z = np.sqrt(b ** 2 + y ** 2)
    cos = (y ** 2 + z ** 2 - b ** 2) / (2 * y * z)
    print(math.degrees(math.acos(cos)))
else:
    y = b - ((2 * (x - org_volume / 2)) / (a ** 2))
    z = np.sqrt(a ** 2 + y ** 2)
    cos = (a ** 2 + z ** 2 - y ** 2) / (2 * a * z)
    print(math.degrees(math.acos(cos)))

Solution (Python):
import math

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

if a*a*b*(1/2) >= x:
    degree = math.degrees(math.atan(a*b*b/(2*x)))
else:
    degree = math.degrees(math.atan((2.0*(b-(x/(a*a))))/a))

print(degree)

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


if(x<=(a*a*b)/2):
    S = x/a
    h = (2*S/b)
    print(90.-math.atan(h/b)/(2.*math.pi)*360)
else:
    
    x /= a
    d = 2*x/a-b
    if(b==d):
        print(0)
    else:
        print(90.-math.atan(a/(b-d))*360/(2*math.pi))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

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

  c=(2*x)/(a*a)-b

  if c>=0:
    tanx=(b-c)/a
    return math.degrees(math.atan(tanx))

  c=(2*x)/(a*b)
  tanx=b/c
  return math.degrees(math.atan(tanx))


print(main())

Solution (Python):
import math 

arr = input().split()
a = int(arr[0])
b = int(arr[1])
x = int(arr[2])
if b*a*a > x:
    ans1 = 90-math.atan(a*a*a/(2.0*(b*a*a-x)))/math.acos(-1)*180
else:
    ans1 = 0.0
ans2 = math.atan(a*b*b/2/x)/math.acos(-1)*180

if a*a*b/2 <= x:
    print (ans1)
else:
    print (ans2)

Solution (Python):
"""
https://atcoder.jp/contests/abc144/tasks/abc144_d
"""
import numpy as np


def calc(a: int, b: int, x: int) -> float:
    half_v = a ** 2 * b / 2
    if x == half_v:
        return 45.0
    elif x > half_v:
        return calc_1(a, b, x)
    else:
        return calc_2(a, b, x)


def calc_1(a: int, b: int, x: int) -> float:
    tan_theta = a ** 3 / (2 * (a ** 2 * b - x))
    theta_rad = np.arctan(tan_theta)
    return float(np.degrees(theta_rad))


def calc_2(a: int, b: int, x: int) -> float:
    tan_theta = 2 * x / (a * b ** 2)
    theta_rad = np.arctan(tan_theta)
    return float(np.degrees(theta_rad))


def load_input_as_int_array() -> np.ndarray:
    return np.array([int(v) for v in input().split(" ")])


def main() -> None:
    a, b, x = load_input_as_int_array()
    result = calc(a, b, x)
    print(90 - result)


main()

Solution (Python):

def nums():
    return list(map(int,input().split(" ")))
def num():
    return int(input())
def yakusu(n):
    res = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            res.add((i,int(n/i)))
    return res
"""
a,b = nums()
if a <= 9 and b <= 9:
    print(a * b)
else:
    print(-1)
"""
"""
n = num()
qq = []
for i in range(10):
    for j in range(10):
        qq.append(i * j)
if n in qq:
    print("Yes")
else:
    print("No")
"""
"""
N = num()
y = yakusu(N)

min = -1

for i in y:
    x,y = i
    if min == -1:
        min = x + y
    elif min > x + y:
        min = x+y

print(min-2)
"""

import math as m
a,b,x = nums()
t = a**2 * b
if (x < (t/2)):
    w = (x * 2) / (a*b)
    ans = m.atan(w/b)
    print(90 - m.degrees(ans))
else:
    yoyu = t - x
    yh = (yoyu *2 ) / a / a
    ans = m.atan(yh/a)
    print(m.degrees(ans))

"""
N,K = nums()
As = nums()
As.sort(reverse=True)
Fs = nums()
Fs.sort(reverse=True)
costs = []
idx = 0
for f in Fs:
    print(f"K={K},F({idx})={f},A({idx})={As[idx]}")
    s_cost = As[idx]
    if f > K and K > 0:
        if s_cost >= K:
            s_cost -= K
            K = 0
        else:
            K -= s_cost
            s_cost = 0
        costs.append((f,s_cost))
    if K > 0:
        if s_cost >= K:
            s_cost -= K
            K -= f
        else:
            K -= s_cost
            s_cost = 0
            
        costs.append((f,s_cost))
    else:
        costs.append((f,s_cost))
    idx += 1
print("---")
res = []
for i in costs:
    c,s = i
    res.append(c*s)
    print(f"{c}x{s},",end="")
print(max(res))
"""

Solution (Python):
import math

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

if x >= a * a * b / 2:
    ans = math.degrees(math.atan2(2 * a**2 * b - 2 * x, a**3))
else:
    ans = math.degrees(math.asin( (a * b**2) / math.sqrt( 4 * x**2 + a**2 * b**4) ))

print(ans)

Solution (Python):
import math

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

q = a*b*b/2/x
w = (2*b-2*x/a**2)/a

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

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/X/2) * 180 / np.pi)
else:
  print(np.arctan(2*B/A-2*X/A/A/A) * 180 / np.pi)

Solution (Python):
import math

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

Solution (Python):
import math
a,b,x=map(int,input().split())
v=a*a*b
if v <= 2*x:
    b1=(v-x)/a*2/a
    c=math.sqrt(a**2+b1**2)
    print(math.degrees(math.acos(a/c)))
else:
    a1=((x/a)*2)/b
    c=math.sqrt(a1**2+b**2)
    print(math.degrees(math.asin(b/c)))

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

import math

def f1(d,H,h):
    if h == H:
        return 90
    if h > H/2:
        return math.degrees(math.atan(d/(2*(H-h))))
    else:
        return math.degrees(math.atan((2*d*h)/(H*H)))

print(str.format('{0:.10f}', 90 - f1(a,b,h)))

Solution (Python):
import numpy as np
import math

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

h = x / (a * a)

h2 = (b - h) * 2

if h2 <= b:
    deg = math.degrees(math.atan(h2 / a))
else:
    h3 = ((x / a) / b) * 2
    deg = math.degrees(math.atan(b / h3))

print(deg)


"""

"""

Solution (Python):
from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math




'''
条件に合うものを絞り込む
data = [1, 2, 3]
s = [x for x in data if x % 3 == 0]
'''

'''
文字配列を数値に
l_si = ['-10', '0', '100']

l_si_i = [int(s) for s in l_si]
'''

'''
a = [2, 4, 6, 8]
b = [3, 6, 9]

print(list(set(a) | set(b)))  
print(list(set(a) & set(b)))  
'''

'''
N = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
while len([x for x in A if x % 2 == 0]) == N:
    A = list(map(lambda y: y / 2, A))
    count += 1
print(count)
'''

'''
.append(要素)
.extend(要素)
.insert(場所,要素)
del 配列名[場所]
-1で末尾で末尾から一つ前
'''
'''
間に空白追加
' '.join(lis)
'''
'''
copy.copy(配列名)
'''
'''
sort()50
sorted(reverse=true)
'''
'''
2分探索
bisect.bisect_left(リスト, 要素)
'''
data = stdin.readline().rstrip().split()
a = float(data[0])
b = float(data[1])
x = float(data[2])
if (b * a * a >= 2 * x):
    print(90.0 - math.degrees(math.atan(2 * x / (a * b * b))))
elif (not a * a * b == x):
    print(90.0 - math.degrees(math.atan(a * a * a / (2 * a * a * b - 2 * x))))
else:
    print(0.0)

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

def gets(a,b,c):
    flg=True
    tanc=math.tan(c)
    if tanc>b/a:
        flg=False
    
    if flg:
        ans=a*b-a*a*math.tan(c)/2
    else:
        ans=(b*b/math.tan(c))/2
    return ans*a

now=45
haba=22.5

"""
for i in range(90):
    m=i-0.0001
    print(gets(a,b,math.radians(i)))

print()    
"""

if a*a*b==x:
    print(0)
else:
    
    
    for bis in range(100000):
        c=math.radians(now)
        
        res=gets(a,b,c)
        if abs(res-x)<10**-15:
            print(now)
            break
        elif res<x:
            now=(now-haba)
        else:
            now=(now+haba)
        haba/=2
    else:
        print(now)

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

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

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

Solution (Python):
import sys
import math

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

sq = a*a*b

if sq/2 == x:
    print("45.00000000")

elif sq/2 > x:
    t = (x*2)/(a*b)
    d = math.atan(b/t)
    print(math.degrees(d))

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

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

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

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

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

Solution (Python):

import math

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


y = (2*x / a**2) - b

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

print(math.degrees(theta))

Solution (Python):
from math import atan, pi
a,b,x = [int(i) for i in input().split()]




ocupado = x/(a*a)



if ocupado == b:
    alfa = pi/2

elif ocupado*2 >= b:
    sobra = b - ocupado

    
    alfa = atan(a / (2*(b-ocupado)))
else:
    alfa = atan((2*a*ocupado) / (b*b))
print("%.10f" %(90 - alfa*180/pi))

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



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

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

Solution (Python):
import math
a, b, x = (int(i) for i in input().split())
t = 2 * (b/a - x/(a*a*a))
z = math.atan(b/a)
rad = math.atan(t)

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

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

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

Solution (Python):
from sys import stdin
import math
a, b, x= [int(x) for x in stdin.readline().rstrip().split()]
if a*a*b/2 < x:
    t = 2 * (a*a*b - x) / (a*a*a)
elif a*a*b/2 == x:
    t = 1
if a*a*b/2 > x:
    t = (a*b*b)/(2*x)
print("{0:.10f}".format(math.degrees(math.atan(t))))

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

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

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

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

if a*a*b == x:
  print(0.0)
else:
  if x <= b*a*a/2:
    l =  2*x/(a*b)
    ans = np.arctan(b/l)
  else:
    l=2*x/a**2-b
    ans=np.arctan((b-l)/a)
  print(180.0*ans/np.pi)

Solution (Python):
import math


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

if 2*x<a*a*b:
    sit=math.atan((a*b*b)/(2*x))
    print(math.degrees(sit))
elif 2*x>a*a*b:
    p1=2*(a*a*b-x)
    p2=a*a*a
    sit=math.atan(p1/p2)
    print(math.degrees(sit))
else:
    print(45.00000)

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

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



p1 = ((2*x)/(a*a)) - b
p2 = b - p1

pp1 = (2*(a*a*b-x))/(a*b) -a
pp2 = a - pp1

ans1 = math.degrees(math.atan(p2/a))
ans2 = math.degrees(math.atan(b/pp2))



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

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

Solution (Python):
import math

def solve():
    a, b, x = map(int, input().split(" "))
    area = float(a * b)
    if x > (area * a / 2.0):
        up_down = float(x / a) * 2.0 / a
        a2 = float(up_down - b)
        b2 = b - a2
        tan = float(b2 / a)
        print('{:.10f}'.format(math.degrees(math.atan(tan))))
        return
    else:
        base = (float(x) / area) * 2.0
        tan = float(base / b)
        print('{:.10f}'.format(90.0 - math.degrees(math.atan(tan))))
        return 

if __name__ == '__main__':
    solve()

Solution (Python):
import math


def run(a, b, x):
    if a*a*b >= 2*x:
        tan = a * (b**2) / (2*x)
    else:
        tan = (2*b) / a - ((2*x) / a**3)
    ret = math.degrees(math.atan(tan))
    return ret


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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

d = x / (a ** 2)
c = -(2 * d - 2 * b)
e = a * d * 2 / b

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

print(r)

Solution (Python):
import math

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

div = (x/(a*a))/b
wide = div * a
bottom = wide * 2.0
if bottom <= a:
    print(math.degrees(math.atan2(b,bottom)))
else :
    high = (b - (x/(a*a)))*2
    print(math.degrees(math.atan2(high,a)))

Solution (Python):
import math

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

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

Solution (Python):
import math

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

if (a**2)*b/2 < x :
    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())
if x >= a**2*b/2:
    ans = 90 - math.degrees(math.atan2(a**3, (2*a**2*b-2*x)))
else:
    
    
    ans = 90 - math.degrees(math.asin(2*x/math.sqrt(a**2*b**4 + 4*x**2)))
print(ans)

Solution (Python):
import math
from decimal import *

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

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

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

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

Solution (Python):
import math

a,b,x = map(int, input().split())
box = a*a*b
ans = 0
if x>=box/2:
    z = a*a
    y = 2*x
    y = y/z
    y -= b
    ans = math.degrees(math.atan2(b-y,a))
else:
    z = a*b
    v = 2*x
    v = v/z
    y = a-v
    ans = math.degrees(math.atan2(b, a-y))
print(ans)

Solution (Python):



import sys
import math


input = sys.stdin.readline


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

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

    elif (a*a*b)/2 > x:
        n = x*2/a/b
        print(math.degrees(math.atan(b/n)))
    else:
        print(45.0)


if __name__ == '__main__':
    main()

Solution (Python):
from math import acos, degrees
a,h,x = (int(x) for x in input().split())
S = x / a
Ss = a*h - S
a_start = a-(2*Ss / h - a)
if a_start > a:
    h_start = 2 * Ss / a
    big = (h_start**2 + a**2) ** 0.5
    angle = degrees(acos(a/big)) 
    
else:
    hb = 2*S / ((h**2+a_start**2)**0.5)
    angle = degrees(acos(hb/h))
print(angle)

Solution (Python):


import sys
import math

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False


        lines.append(input())
    else:
        debug = False
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (a, b, x) = [int(e) for e in lines[0].split(" ")]

    return (a, b, x)

def solve(l, h, v):


    max_v =  l * l * h
    tan = 0
    if v > 0.5 * max_v:
        tan = 2*h/l - 2*v/(l*l*l) 
    else:
        tan = h*h*l/(2*v)

    theta = math.atan(tan)

    return math.degrees(theta)

def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r)
    else:
        print("%s" % result)

if __name__ == '__main__':

    main()

Solution (Python):

import math
A, B, C = map(int, input().split())
x = C / A**2
height = 2 * x - B
if (height >= 0):
    y = B -height
    print(math.degrees(math.atan(y/A)))
else:
    z = 2*C / (A*B)
    print(math.degrees(math.atan(B/z)))

Solution (Python):
import numpy as np

a, b, x = map(int, input().split(' '))
theta = 0
if x <= a ** 2 * b / 2:
    theta = np.arctan((a * b ** 2) / (2 * x))
else:
    theta = np.arctan(2 * (a ** 2 * b - x) / (a ** 3))
print(np.rad2deg(theta))

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

Solution (Python):
import sys
from io import StringIO
import unittest
import math


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

    tan_theta = 2*(b/a-x/math.pow(a, 3))
    tan_theta2 = a * pow(b, 2) / (2 * x)

    if math.pow(a, 3) / 2 * tan_theta < x:
        theta = math.atan(tan_theta)
    else:
        theta = math.atan(tan_theta2)

    print(math.degrees(theta))


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 2 4"""
        output = """45.0000000000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """12 21 10"""
        output = """89.7834636934"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """3 1 8"""
        output = """4.2363947991"""
        self.assertIO(input, output)


if __name__ == "__main__":
    
    resolve()

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

v_max = a * a * b
v_emp = a * a * b - x

if v_emp < v_max / 2:
    tan = 2 * v_emp / (a ** 3)
else:
    tan = a * b * b / (2 * x)

import math
deg = math.degrees(math.atan(tan))

print(deg)

Solution (Python):
import math

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

H = x / (a**2)
nokori = b - H

sa = nokori * 2

ans = math.degrees(math.atan2(sa, a))
if H * 2 >= b:
    print(ans)
else:
    
    men = H*a
    
    _x = men * 2 / b
    
    ans = math.degrees(math.atan2(b, _x))
    print(ans)

Solution (Python):
import math
a,b,x = list(map(int,input().split()))
height = x / (a**2)
margin = b-height
squaremargin = margin*a
if squaremargin <= a*b/2:
        tiltedmargin = squaremargin/a*2
        rad = math.atan(tiltedmargin/a)
else:
        tiltedmargin = squaremargin*2/b-a
        rad = math.atan(b/(a-tiltedmargin))
print(rad*(180/3.141592653589793238))

Solution (Python):
import math
a, b, x = list(map(float, input().split()))
if x/a >= 0.5 * a * b:
    area = (a * b) - (x/a)
    c = 2 * area / a
    d = (a ** 2 + c ** 2) ** (1/2)
    angle = math.asin(c/d)
    angle = math.degrees(angle)
else:
    area = (x/a)
    c = 2 * area /b
    d = (b ** 2 + c ** 2) ** (1/2)
    angle_k = math.asin(c/d)
    angle_k = math.degrees(angle_k)
    angle = 90- angle_k
print(angle)

Solution (Python):

import sys
import math
sys.setrecursionlimit(10000)
INF = 1<<32


def solve(a: int, b: int, x: int):
    y = float(x)/float(a)
    ans = .0
    if (a**2 * b - x) == 0:
        ans = 0.0
    elif y >= a*b/2:
        bd = 2.0*(a*b-y)/a
        ans = 90.0-math.degrees(math.atan(a/bd))
    else:
        ad = 2.0*y/b
        ans = 90.0-math.degrees(math.atan(ad/b))

    print(ans)

    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):
a,b,x = map(int,input().split())

import math

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

Solution (Python):

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

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

print(ans)

Solution (Python):
import math

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

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

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

org_S = x/a

if org_S>=a*b/2:
  delta=(a*b)-org_S
  tan_theta=2*delta/(a*a)
  theta=math.atan(tan_theta)
  print(math.degrees(theta))
else:
  t=(2*org_S)/b
  tan_theta=t/b
  theta=math.atan(tan_theta)
  print(90-math.degrees(theta))

Solution (Python):
import math

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

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


print(theta*180/math.pi)

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

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

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

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

print(theta)

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

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

if x >= a*a*b/2:
    y = (-1)*b + 2*x/(a**2)
    if b != y:
        d = math.atan(a / (b-y))
    else:
        print(0)
        exit()
else:
    y = 2*x/(a*b)
    d = math.atan(y/b)
print(90 - math.degrees(d))

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

S = x / a
half = a * b / 2

if S > half:
  S = a * b - S
  y = math.atan(2*S/(a*a))
else:
  y = math.atan(b*b/(2*S))

print(math.degrees(y))

Solution (Python):
input = str(input()).split(" ")
input = [int(x) for x in input]

a=input[0]
b=input[1]
x=input[2]

import math


height = x/a/a
if height <= b/2:
    teihen_height = 2*x/a/b
    print(math.degrees(math.atan(b/teihen_height)))
elif height == b:
    print(0)
else:
    nokori_height = b - height
    print(90-math.degrees(math.atan(0.5*a/nokori_height)))

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

V=a**2*b
if x==V:
    print('{:.10f}'.format(0))
elif x<=V/2:
    alpha=np.arctan(2*x/a/b**2)
    angle=90-alpha/np.pi*180
    print('{:.10f}'.format(angle))
else:
    angle=90-np.arctan(a**3/2/(a**2*b-x))/np.pi*180
    print('{:.10f}'.format(angle))

Solution (Python):
import math

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

V = a**2*b

if x > V/2:
  Va = V - x
  res = 2*Va/(a**2)
  deg = math.atan(res/a)

else:
  Va = x
  res = 2*Va/(a*b)
  deg = math.atan(b/res)

deg = math.degrees(deg)

print(deg)

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

print('{:.10f}'.format(res))

Solution (Python):
import math

c = list(map(float, input().split()))
a = c[0]
b = c[1]
x = c[2]
if x <= a * a * b / 2.0:
  print(90.0 - math.atan((x / a * 2.0 / b) / b) * 180.0 / math.pi)
else:
  print(math.atan(((a * a * b - x) / a * 2.0 / a) / a) * 180.0 / math.pi)

Solution (Python):
from math import atan,pi
import sys
def input(): return sys.stdin.readline().strip()

def main():
    a,b,x=map(int,input().split())
    y = 2*x/(a*b)
    if y <= a:
        print(180*atan(b/y)/pi)
    else:
        z=2*b-(2*x)/(a*a)
        print(180*atan(z/a)/pi)
    
main()

Solution (Python):
import time
import math
a,b,x = map(int,input().split())
x /= a
c = a*b/2
if x<c:
    l,r = 0,90
    for i in range(1000):
        mid = (l+r)/2
        S = b*b*math.tan(math.radians(mid))/2
        if S<=x: l = mid
        else: r = mid
    print(90-mid)
elif x==c:
    print(math.degrees(math.atan(a/b)))
else:
    l,r = 0,90
    for i in range(1000):
        mid = (l+r)/2
        S = a*b-a*a/math.tan(math.radians(mid))/2
        if S<=x: l = mid
        else: r = mid
    print(90-mid)

Solution (Python):


import sys
from math import *

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    a, b, x = i2nn()
    if 2 * x > a * a * b:
        r = atan(2 / a**2 * (a * b - x / a))
    else:
        r2 = atan(2 * x / (a * b * b))
        r = pi / 2 - r2
    print(r / pi * 180)
    return

main()

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

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


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

Solution (Python):
import math
from functools import reduce




a, b, x = map(int, input().split())
total = a * a * b
def get_vol(vals, x, y):
    return vals * 2.0 / (x * y)

if x == total:
    print(0.0)
elif x > total // 2:
    h = get_vol(total - x, a, a)
    angle = math.degrees(math.atan( h * 1.0 / a))
    print(angle)
else:
    h = get_vol(x, b, b)
    angle = math.degrees(math.atan(h * 1.0/ a))
    print(90 - angle)

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

import numpy as np

if a*a*b/2 < x:
    d = np.arctan(2*(a*a*b-x)/(a*a*a))
    print(d*180/np.pi)
else:
    d = np.arctan(b*b*a/(2*x))
    print(d*180/np.pi)

Solution (Python):
import math

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math
[a,b,x]=list(map(int,input().split()))
if a*a*b/2<=x:
	A=b/a
	B=x/(a*a*a)
	tan=((A**2-B**2)/(A+B))*2
	thita=math.atan(tan)
	dosu=math.degrees(thita)
else:	
	tan=2*x/(a*b*b)
	thita=math.atan(tan)
	dosu=90-math.degrees(thita)
print(dosu)

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

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

Solution (Python):
import math
  
inp = input().split(" ")
inp = [float(i) for i in inp]

a = inp[0]
b = inp[1]
x = inp[2]

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

Solution (Python):
import math 

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

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

if x == a*a*b/2:
    print(math.degrees(math.atan2(b,a)))
elif x > a*a*b/2:
    c = 2*(a*a*b-x)/(a**2)
    print(math.degrees(math.atan2(c,a)))
elif x < a*a*b/2:
    c = (2*x)/(a*b)
    print(math.degrees(math.atan2(b,c)))