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


check=(a*a*b)-x
check=check /(a*a)

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

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

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

Solution (Python):
import sys,collections as cl,bisect as bs,math 
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def prime_decomposition(n): 
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(i)
    i += 1
  if n > 1:
    table.append(int(n))
  return table

def make_divisors(n): 
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors




a,b,x = m()

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

elif x >= a*a*b/2:
    kkk = 2 * x / (a**2) - b

    on = b - kkk

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

    k = math.degrees(math.atan(b/kkk))
    print(k)

Solution (Python):
import numpy as np

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

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

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

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

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

from math import atan,degrees


X=x/a

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

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

Solution (Python):
import numpy as np

a, b, x = map(int, input().split())
h = x / a ** 2
if 2 * h < b:
    c = 2 * x / (a * b)
    rad = np.arctan(b / c)
else:
    rad = np.arctan(2 * (b - h) / a)
print(rad * 180 / np.pi)

Solution (Python):
import math

a, b, x = (int(i) for i in input().split())
if x>=(a*a*b)/2:
    ta=(2*(a*a*b-x))/(a*a*a)
    print(math.degrees(math.atan(ta)))
else:
    ta=(2*x)/(a*b*b)
    print(90-math.degrees(math.atan(ta)))

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

Solution (Python):

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

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

Solution (Python):
import math
A, B, X = map(int, input().split())
S = X/A
pi = math.acos(-1)

if S > A*B/2:
    print(math.atan((A*B-S)*2/(A**2))*180/pi)
else:
    print(math.atan(B*B/2/S)*180/pi)

Solution (Python):


import math


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

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

  print(t * 180 / math.pi)


if __name__ == '__main__':
  main()

Solution (Python):
import sys
import math

input = sys.stdin.readline

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

if x>(a**2*b)/2.0:
	h = x/(a**2)
	sh = 2*h-b
	dh = b-sh

	theta = math.degrees(math.atan(dh/a))
else:
	h = (2.0*x)/(a*b)
	theta = math.degrees(math.atan(b/h))

print(theta)

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

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

Solution (Python):
import math

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

if x < a * a * b / 2:

	c1 = 2 * x / (b * a)
	
	r1 = math.atan2(b, c1) * 180.0 / math.pi

	print(r1)
else:

	c2 = (a * b - x / a) * 2 / a
	
	r2 = math.atan2(c2, a) * 180.0 / math.pi
	
	print(r2)

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

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

Solution (Python):
import numpy as np

a,b,x=map(int,input().split())
S=a**2*b-x

if a**2*b/2 <= x:
    z=S*2/(a**2)
    rad=np.arctan(z/a)
else:
    z=x*2/(a*b)
    rad=np.arctan(b/z)
print(np.rad2deg(rad))

Solution (Python):
import math

a, b, x = map(float, input().split())
xx = x / (a**2)

if xx < b / 2:
	aa = ((a * xx) * 2) / b
	ans_2 = math.degrees(math.atan(aa/b))
	ans = 90 - ans_2
else:
	bb = b - xx
	aa = a / 2
	ans_2 = math.degrees(math.atan(bb/aa))
	ans = ans_2


print(ans)

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

Solution (Python):
import math

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

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

Solution (Python):
import math


def main():
    a, b, x = map(int, input().split())
    x /= a
    if x <= a * b / 2:
        c = x * 2 / b
        ans = math.atan2(b, c) * 360 / (math.pi * 2)
    else:
        y = a * b - x
        c = y * 2 / a
        ans = math.atan2(c, a) * 360 / (math.pi * 2)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import queue
import math
"""
N = int(input())



A = []
for i in range(N):
	A.append(int(input()))

print(A)

"""
(a,b,x) = (int(i) for i in input().split(" "))
mn = 0
mx = 100
while mx-mn > .0000000001:
	md = (mx+mn)/2
	al = b/math.tan(md*math.pi/180)
	if al < a:
		n = a*al*b/2
	else:
		n=(b-b*a/al/2)*a*a
	if n < x:
		mx = md
	else:
		mn = md
print(md)

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

if a*b/2*a < v:
	tanres = (2*b-2*v/(a*a))/a
else:
	tanres = a*b*b/(2*v)
arc = math.atan(tanres)
deg = arc*180/math.pi
print('%.20f'%deg)

Solution (Python):
from math import atan2, degrees
A, B, X = map(int, input().split())
if X < A*A*B/2:
    theta = atan2(A*B*B, 2*X)
else:
    theta = atan2(2*(A*A*B-X),A**3)
print(degrees(theta))

Solution (Python):
from math import *
A, B, X = map(int, input().split())
X /= A
if A*B/2 > X:
    l = 2 * X / B
    print(degrees(atan(B/l)))
else:
    y = A * B - X
    l = 2 * y / A
    print(degrees(atan(l/A)))

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

if x <= a * a * b / 2:
    c = 2 * x / (a * b)
    ans = math.atan2(b, c)
    ans *= 360 / (2 * math.pi)
else:
    c = 2 * b - 2 * x / (a**2)
    ans = math.atan2(c, a)
    ans *= 360 / (2 * math.pi)

print(ans)

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

l = 2*h - b
c = 2 * a * h / b

if l >= 0:
    print("%.10f"%(180 / pi * atan((b-l)/a)))
else:
    print("%.10f"%(180 / pi * atan(b/c)))

Solution (Python):

import math

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

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

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

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

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

print(ans)

Solution (Python):
import numpy as np

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

tot = a*a*b

if tot//2 <= x:
    t = 2*(tot-x)/(a*a)
    print(np.rad2deg(np.arctan(t/a)))
else:
    t = 2*x/(a*b)
    print(90-np.rad2deg(np.arctan(t/b)))

Solution (Python):
import math

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

hanbun=x>(a*a*h/2)

if(hanbun):
    takasa=(x/a/a)*2-h
    katamuki=(h-takasa)/a
    print(math.degrees(math.atan(katamuki)))
else:
    haba=2*x/a/h
    print(math.degrees(math.atan(h/haba)))

Solution (Python):
import math

a, b, x = list(map(int, input().split()))
c = 2 * x / a / b
if c > a:
    bt = 2 * (b - x / a / a)
    print(math.degrees(math.atan2(bt, a)))
else:
    print(math.degrees(math.atan2(b, c)))

Solution (Python):
import math

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

s = x / a
t = s / a

if t * 2 > b:

    print (math.degrees(math.atan((b-t)/(a*0.5))))

else:

    tei = s * 2 / b

    print (math.degrees(math.atan(b / tei)))

Solution (Python):
import sys

stdin = sys.stdin

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

a, b, x = na()
s = x/a
import math

if s <= a*b/2:
    aa = s*2/b
    print("{:.14f}\n".format(math.atan2(b, aa)/math.pi*180))
else:
    bb = (s-a*b/2)*2/a
    print("{:.14f}\n".format(math.atan2(b-bb, a)/math.pi*180))

Solution (Python):
import numpy as np

A, B, X = map(int, input().split())
if A**2*B/2 > X:
    d = X*2/B/A
    ans = np.arctan(B/d)/np.pi*180
else:
    d = X*2/A/A - B
    ans = np.arctan((B-d)/A)/np.pi*180
print(ans)

Solution (Python):

from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

a,b,x = inpl()

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

Solution (Python):
from sys import stdin
from math import atan

def input():
    return stdin.readline()[:-1]


def intput():
    return int(input())


def sinput():
    return input().split()


def intsput():
    return map(int, sinput())


a, b, x = intsput()

if x / a > 0.5 * a * b:
    print(atan((2 * a ** 2 * b - 2 * x) / a ** 3) / 3.14159265358979 * 180)
else:
    print(atan(a * b ** 2 / 2 / x) / 3.14159265358979 * 180)

Solution (Python):
import math

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

Solution (Python):
import math
a, b, x = [int(i) for i in input().split()]
m = a * a * b
if x >= m/2:
    c = (m - x) * 2 / (a ** 2)
    print(math.atan2(c, a)/math.pi*180)
else:
    c = x * 2 / (a * b)
    print(math.atan2(b, c)/math.pi*180)

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

Solution (Python):




import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 

from math import atan2, pi

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

if a*a*b/2 > x:
    c = (x)*2/b/a
    print(atan2(b,c)*360/2/pi)

else:
    c = 2*(a*a*b-x)/a/a
    print(atan2(c,a)*360/2/pi)

Solution (Python):
import math
a, b, x = [int(i) for i in input().split()]
c = (2 * x / a**2 ) - b
if c <= 0:
    c = (2 * x) / (a * b)
    print(math.degrees(math.atan2(b, c)))
else:
    print(math.degrees(math.atan2(b - c, a)))

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)))