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

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

if c >= b/2:
    tanth = 2*(b-c)/a
    deg = math.atan(tanth)*180/math.pi
else:
    tanth = b**2/(2*a*c)
    deg = math.atan(tanth)*180/math.pi

print(deg)

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

Solution (Python):



import math



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






d = a * a * b


if x * 2 > d:
    x = d - x
    xx = 2 * x / (a * a * a)
    theta = math.atan(xx)
    print(theta * 180 / math.pi)

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

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

Solution (Python):
import numpy

a, b, x = map(int, input().split())
if a * b / 2 < x / a:
    theta = numpy.arctan(2 * (b / a - x / a ** 3))
else:
    theta = numpy.arctan(a * b ** 2 / 2 / x)

theta = numpy.rad2deg(theta)
print(theta)

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

if s<=half:
    y = (2*s)/b
    z = math.sqrt(b**2+y**2)
    alpha = b/z
    alpha = math.asin(alpha)
    alpha = math.degrees(alpha)

    print(alpha)

if s>half:
    z = math.sqrt(b**2+a**2)

    alpha = b/z
    alpha = math.asin(alpha)
    alpha = math.degrees(alpha)

    beta = a/z
    beta = math.asin(beta)
    beta = math.degrees(beta)

    l = 2*(s-half)/(math.sin(math.radians(90-alpha))*z)
    k = math.sqrt(z**2+l**2-2*l*z*math.cos(math.radians(90-alpha)))

    gamma = 2*(s-half)/(k*z)
    gamma = math.asin(gamma)
    gamma = math.degrees(gamma)

    print(90-(gamma+beta))

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

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

Solution (Python):
import math

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

main()

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

Solution (Python):
import math
a,b,x = [ int(r) for r in input().split(' ') if len(r) > 0]

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

Solution (Python):
import math

a, b, x = [int(n) for n in input().split()]
v = a**2 * b /2


if v == x:
    theta = math.atan(b/a)

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

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

a,b,x = I()

if a**2*b <= 2*x:
  ama = a**2*b-x
  ran = 2*ama/(a**2)
  print(90-180/math.pi*math.atan2(a,ran))
else:
  ran = 2*x/(a*b)
  print(90-180/math.pi*math.atan2(ran,b))

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

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

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

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

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

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

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

Solution (Python):




import sys
import math
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    a,b,x=map(int, readline().rstrip().split())
    if x <= a*a*b/2:
        l = x*2/b/a
        print(math.degrees(math.atan(b/l)))
        return
    l = (2*x)/(a*a)-b
    print(math.degrees(math.atan((b-l)/a)))
    
    
    
    

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

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

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

Solution (Python):
import sys
import math
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
    
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
    
    
def main():
    a,b,x = MI()
    a2b = (a**2)*b
    a3 = (a**3)/2
    ab2 = a*(b**2)/2
    
    pai = math.pi/2
    low = 0
    high = math.pi/2
    mid = (low+high)/2
    
    while high - low > 0.0000000000001:
        if a * math.tan(pai-mid) < b:
            v = a2b - a3 * math.tan(pai-mid)
        else:
            v = ab2 * math.tan(mid)
        
        if v < x:
            low = mid
        else:
            high = mid
            
        mid = (low+high)/2

    print(90 - math.degrees(mid))

if __name__ == "__main__":
    main()

Solution (Python):
import math

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

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

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

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

Solution (Python):
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7

INF = 10**18
eps = 10**-7

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

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

Solution (Python):
from math import tan, atan2, pi, degrees


def f(theta):
    if theta < thres:
        return V - a ** 3 * tan(theta) / 2
    else:
        return a * b * b / tan(theta) / 2


eps = 1e-9
a, b, x = map(int, input().split())
V = a * a * b
thres = atan2(b, a)

bad, good = pi / 2, 0
while bad - good > eps:
    mid = (bad + good) / 2
    if f(mid) >= x:
        good = mid
    else:
        bad = mid
print(degrees(good))

Solution (Python):
import math

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

Solution (Python):



from math import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq














import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7


INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
a,b,x = readInts()
x /= a
import math
PI = math.pi
if x > a*b//2:
    print("{:.10}".format(math.atan2((a*b-x)*2, a*a)*180/PI))
else:
    print("{:.10}".format(math.atan2(b*b, x*2)*180/PI))

Solution (Python):
from math import pi
from math import atan2

a, b, x = map(float, input().split())
ans = 0
x /= a
if (x > a*b / 2): 
    ans = atan2((a*b-x)*2, a*a) * 180 / pi
else:
    ans = atan2(b*b, x*2) * 180 / pi
print (ans)

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

Solution (Python):
from math import atan, pi

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

ans *= 180 / pi
print(ans)

Solution (Python):
a, b, x = map(int, input().split())
if x > (a**2)*b/2:
    t = 2*((a**2)*b-x)/(a**3)
else:
    t = a*(b**2)/(2*x)

import math
ans = math.degrees(math.atan(t))
print(ans)

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

Solution (Python):
import math

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

a, b, x = map(int, input().split())
l, r = 0.0, 90.0
for i in range(1000):
  m = (l+r)/2
  if f(m) <= x: r = m
  else: l = m
print('{0:.10f}'.format(l))

Solution (Python):
import math

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

vol = a * a * b

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

Solution (Python):
import math
a,b,x = [ int(r) for r in input().split(' ') if len(r) > 0]

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

Solution (Python):
import math

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


if __name__ == '__main__':
    main()

Solution (Python):

from math import atan2,pi

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

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

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

Solution (Python):
import numpy
a,b,x=map(int,input().split())
V=a*a*b
if x<=V/2:
    y=2*x/b/a
    theta=numpy.arctan(b/y)
    print(theta*360/2/numpy.pi)
else:
    x=V-x
    y=2*x/a/a
    theta=numpy.arctan(y/a)
    print(theta*360/2/numpy.pi)

Solution (Python):
import math as m
a,b,x=map(int,input().split())
x/=a
P=m.acos(-1.0)
if x>a*b/2:print(m.atan2((a*b-x)*2,a*a)*180/P)
else:print(m.atan2(b*b,x*2)*180/P)

Solution (Python):
from math import *
a,b,x=map(int,input().split())
x=x/a
if x<=a*b/2:
  t=2*x/b
  c=sqrt(b**2+t**2)
  ans=90-degrees(asin(t/c))
else:
  t=2*(a*b-x)/a
  c=sqrt(a**2+t**2)
  ans=90-degrees(asin(a/c))
print(ans)

Solution (Python):
import math

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

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

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

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

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

if V/2<X:
  print(degrees(atan(2*(V-X)/A**3)))
else:
  print(degrees(atan(A*B*B/2/X)))

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

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

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

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

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

Solution (Python):
import math
pi=math.pi
def rtod(rad):
    return 180/pi*rad
a,b,x=map(int,input().split())


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

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    a,b,x = LI()
    ok = 0
    ng = 90

    while ng - ok >= 10**(-8):
        middle = (ng+ok) /2
        volume = 0

        if a*math.tan(math.radians(middle)) <= b:
            volume = a**2*b - a**3*math.tan(math.radians(middle))/2
        else:
            volume = a*b**2/(2*math.tan(math.radians(middle)))
        if volume >= x:
            ok = middle
        else:
            ng = middle
    
    ans = ok
    print(ans)
main()

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    a,b,x = LI()
    ans = 0

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

Solution (Python):
from math import atan, degrees

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

if __name__ == '__main__':
    main()

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

h=x/a/a
A=h*a

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

print(ans)

Solution (Python):
import math
import decimal
a,b,x = map(int, input().split(" "))
if a * a * b * 0.5 < x:
  print(math.atan((2 * b - (2 * x / a / 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())
y = (a**2)*b
h = x/(a**2)

def get_angle_from_sides(a, b, c):
    return math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))

def checkio(a, b, c):
    try:
        angles = [get_angle_from_sides(*abc) for abc in ((a, b, c), (b, c, a), (c, a, b))]
        result = sorted((math.degrees(a)) for a in angles)
        return [0, 0, 0] if 0 in result else result
    except ValueError:
        return [0, 0, 0]
count = 0
if y == x:
  pass
elif y/2 <=x:
  if a>=2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[0]
  elif a<2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[1]
elif y/2>x:
  z = 2*x/(a*b)
  if b>=z:
    m = checkio(b,z,math.sqrt(b**2+(z)**2))
    count = m[1]
  elif b<z:
    m = checkio(b,z,math.sqrt(b**2+(z)**2))
    count = m[0]

print(count)

Solution (Python):
import sys
from math import *

input = sys.stdin.readline

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

s = x / a


if s > a*b / 2:
    sankaku = a*b - s
    h = (a*b - s) * 2 / a 
    print(degrees(atan(h/a)))
else:
    w = 2*s/b
    print(degrees(atan(b/w)))

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

Solution (Python):

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

Solution (Python):

"""
Created on Wed Sep  9 19:58:50 2020

@author: liang
"""
"""
【三角形の面積の公式】
S = 1/2 * a * b
"""
import math
a, b, x = map(int, input().split())
L = math.sqrt((x/a/b)**2 + b**2)
if x >= a**2*b/2:
    ans = math.degrees(math.atan((b-x/a**2)/a*2))
else:
    ans = math.degrees(math.atan((a*b**2)/x/2))
    
print(ans)

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

Solution (Python):
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right 
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import sin, cos, tan, asin, acos, atan, degrees, radians

sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7

def lcm(x,y):
    return x*y//gcd(x,y)
def lgcd(l):
    return reduce(gcd,l)
def llcm(l):
    return reduce(lcm,l)
def powmod(n,i,mod):
    return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
    return x.bit_length()
def div10(x):
    return len(str(x))-(x==0)
def perm(n,mod=None):
    ans = 1
    for i in range(1,n+1):
        ans *= i
        if mod!=None:
            ans %= mod
    return ans
def intput():
    return int(input())
def mint():
    return map(int,input().split())
def lint():
    return list(map(int,input().split()))
def ilint():
    return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
    print(l[0] if x else l[1])
def lprint(l, sep='\n'):
    for x in l:
        print(x, end=sep)
def ston(c, c0='a'):
    return ord(c)-ord(c0)
def ntos(x, c0='a'):
    return chr(x+ord(c0))
class counter(dict):
    def __init__(self, *args):
        super().__init__(args)
    def add(self,x):
        self.setdefault(x,0)
        self[x] += 1
class comb():
    def __init__(self, n, mod=None):
        self.l = [1]
        self.n = n
        self.mod = mod
    def get(self,k):
        l,n,mod = self.l, self.n, self.mod
        k = n-k if k>n//2 else k
        while len(l)<=k:
            i = len(l)
            l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
        return l[k]

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

Solution (Python):
def main():
    import sys
    readline = sys.stdin.buffer.readline

    import math

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
from math import atan2, degrees

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

if a * a * b / 2 >= x:
    c = 2 * x / a / b
    print(degrees(atan2(b, c)))
else:
    c = 2 * x / a / a - b
    print(degrees(atan2(b - c, a)))

Solution (Python):
import math
def at(n):
	return math.degrees(math.atan(n))

def main():
	a, b, x = [int(p) for p in input().split(" ")]
	V = a * a * b
	if x < V / 2:
		print(at(a * b * b / (2 * x)))
	else:
		print(at(2*(a*a*b-x)/a**3))

main()

Solution (Python):
import math


def LI():
    return list(map(int, input().split()))


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

Solution (Python):
from math import pi, tan, atan, degrees
 
a, b, x = [int(i) for i in input().split()]
 
theta = (pi * 0.5) - atan(2 * x / (a * b**2))
 
if b * tan(pi * 0.5 - theta) <= a:
    print(degrees(theta))

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

Solution (Python):
import math
a,b,x=map(int,input().split())
V=a*a*b
if 2*x<=V:
    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):
a, b, x = map(int, input().split())

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

import math
p = math.atan(t)
p = math.degrees(p)
print(p)

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

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

s = x/a
if x >= a**2*b/2:
  print(degrees(atan2(2*(a*b-s)/a, a)))
else:
  print(degrees(atan2(b, 2*s/b)))

Solution (Python):

import math


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

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

    print(math.degrees(ans))


if __name__ == "__main__":
    main()

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

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


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


l=0
r=90
while r-l>=10**-6:
  mid=(l+r)/2
  
  if x-10**-6<=f(a,b,mid)<=x+10**-6:
    print(mid)
    exit(0)
  if f(a,b,mid)>x:
    l=mid
  else:
    r=mid
print(l)

Solution (Python):
from math import atan, degrees

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

Solution (Python):
from math import atan, degrees

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

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

import math
r = 180/math.pi

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

Solution (Python):
import math
A, B, X = map(int, input().split())
h = X / (A*A)
r = 0
deg = 0
if (2 * X) - (B * A * A) > 0:
  r = math.atan(2 * (B-h) / A)
elif (2 * X) - (B * A * A) == 0:
  r = math.atan(B / A)
else:
  h = (2 * X) / (A * B)
  r = math.atan(B / h)
deg = math.degrees(r)
print(deg)

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


def is_ok(theta):
    if math.tan(theta) * b < a:
        return x <= math.tan(theta) * b * b / 2
    else:
        p = a/math.tan(theta)
        return x <= a*p/2+a*(b-p)


def bisect(ng, ok):
    while (abs(ok - ng) > 1e-9):
        mid = (ok + ng) / 2
        if is_ok(mid):
            ok = mid
        else:
            ng = mid
    return ok


ans = bisect(0, math.pi)
ans = 90- ans * 180 / math.pi
print(ans)

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

if sq >= x:
    A1 = 2*x/(a*b)
    num = math.atan(b/A1)
else:
    B1 = 2*x/a**2 - b
    num = math.atan((b-B1)/a)

print(math.degrees(num))

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

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

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    import math
    mod=10**9+7
    a,b,x3=MI()
    
    x=x3/(a**2) 
    
    if (a*b)//2 >= a*x :
        y=(2*a*x)/b
        th=math.atan2(b,y)
        
    else:
        rem=a*(b-x)
        z=rem*2/a
        th=math.atan2(z,a)
        
    print(th/math.pi * 180)
        

main()

Solution (Python):
from math import atan, degrees

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

Solution (Python):
import math
from math import gcd,pi,sqrt
INF = float("inf")

import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    a,b,x = i_map()
    if a*a*b<x*2:
        water_y = x/a**2
        left_y = b-water_y
        half_x = a/2
        d = math.degrees(math.atan(left_y/half_x))
        print(d)
    else:
        c = (x*2)/(a*b)
        c = math.degrees(math.atan(b/c))
        print(c)


if __name__=="__main__":
    main()

Solution (Python):
import math

def main():
    a, b, x = map(int, input().split())
    if a*a*b == x:
        print(0)
        return
    mid = a**2*b/2
    c = x/(a**2)
    if mid == x:
        ans = 90 - math.degrees(math.atan(a/b))
    elif mid < x:
        d = 2*x/(a**2) - b
        ans = 90 - math.degrees(math.atan(a/(b-d)))
    else:
        d = 2*a*c/b
        ans = 90 - math.degrees(math.atan(d/b))

    print(ans)

if __name__ == "__main__":
    main()

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

Solution (Python):


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

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

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

Solution (Python):
import math        






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

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

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

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