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):
a,b,x=map(int,input().split())
def water(a,b,x):
  import math
  if math.tan(math.radians(x))<=b/a:
    return (((a**2)*math.tan(math.radians(x))))/2+a*(b-a*math.tan(math.radians(x)))
  else:
    return b**2/(2*math.tan(math.radians(x)))

p=0
q=90
r=0
while r<=1000:
  if water(a,b,(p+q)/2)<=x/a:
    p=p
    q=(p+q)/2
    r=r+1
  else:
    p=(p+q)/2
    q=q
    r=r+1

print((p+q)/2)

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

Solution (Python):
import sys
import math
input = sys.stdin.readline
a, b, x = [int(x) for x in input().strip().split()]
if x >= a ** 2 * b / 2:
    theta = math.degrees(math.atan(2 * (a ** 2 * b - x) / (a ** 3)))
else:
    theta = math.degrees(math.atan(a * (b ** 2) / (2 * x)))
print(theta)

Solution (Python):
import math

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

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

Solution (Python):
import sys
import math

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

if x*2==V:
    ans=45
    
elif x*2<V:
    y=2*x/(b*a)
    ans=math.degrees(math.atan(b/y))
else:
    y=(2*(V-x))/(a*a)
    ans=math.degrees(math.atan(y/a))


print(ans)

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

tansita = 2 * margin / (A ** 3)

if A * tansita <= B:
  Ans = math.degrees(math.atan(tansita))
  
else:
  tansita = 2 * X / (A * B * B)
  Ans = math.degrees(math.atan(tansita))
  Ans = 90 - Ans

print(Ans)

Solution (Python):
import math;

input_line = input().rstrip().split(' ')
a = int(input_line[0])
b = int(input_line[1])
x = int(input_line[2])

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

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

if x >= a * a * b / 2:
    h0 = x / a / a
    tanr = (b - h0) * 2 / a
else:
    h1 = 2 * x / a / b
    tanr = b / h1

print(math.degrees(math.atan(tanr)))

Solution (Python):

import sys
from math import *
input = lambda: sys.stdin.readline()[:-1]
sys.setrecursionlimit(10**8)
inf = float('inf')
mod = 10**9+7

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

d = degrees(atan(2*((b-(x/(a**2)))/a)))
if d>=degrees(atan(b/a)):
    d=degrees(atan(1/(2*x/a/b/b)))
print(d)

Solution (Python):
import math
a, b, x = map(int, input().split())
space = a*a*b
aki = space - x
if x >= space / 2:
    sankaku = aki / a
    y = sankaku * 2 / a
    z = (a*a + y*y)**0.5
    ans = math.degrees(math.atan(y/a))
else:
    sankaku2 = x / a
    a2 = sankaku2 * 2 / b
    d = (a2*a2 + b*b)**0.5
    ans1 = math.degrees(math.atan(a2/b))
    ans = 90 - ans1
print(ans)

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

if(x <= a*b/2):
    print(90-math.degrees(math.acos(b/math.sqrt((x/b*2)**2+b**2))))
else:
    print(math.degrees(math.acos(a/math.sqrt(((a*b-x)/a*2)**2+a**2))))

Solution (Python):
import math
import numpy as np

pi = np.pi
n=input()
t=n.split()
a= int(t[0])
b=int(t[1])
x=int(t[2])

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

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

max_=a**2*b
if x<=max_/2:
  num=x*2/a/b
  num2=math.sqrt(b**2+num**2)
  print(90-math.degrees(math.asin(num/num2)))
else:
  num=x*2/a/a-b
  num2=math.sqrt((b-num)**2+a**2)
  print(90-math.degrees(math.asin(a/num2)))

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

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

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

n=x/a/a
if n>b/2:
    n=(b-n)*2
    atan = math.degrees(math.atan(n/a))
    print('{:.10f}'.format(atan))
else:
    n=n/b*2*a
    atan = math.degrees(math.atan(b/n))
    print('{:.10f}'.format(atan))

Solution (Python):
import math

    
def main():
    Input = [input() for i in range(1)]
    
    a,b,x = list(map(int,Input[0].split()))
    if x == a*a*b:
        print(0)
    else:
        a = float(a)
        b = float(b)
        x = float(x)
        ans = 90-math.atan(a/(2*(b-x/(a*a))))*180/math.pi
        if b * math.tan((90-ans)*math.pi/180) < a:
            ans = 90-math.atan(2*x/a/b/b)*180/math.pi
        print(ans)
        
if __name__ == "__main__":
    main()

Solution (Python):
import math

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

v = a*a*b

h = x / (a*a)

if 2*x <= v:
	
	num = (2*x) / (a*b)
	
	ans = math.degrees(math.atan(b/num))
	print('{:.12g}'.format(ans))
else:
	
	num = 2*(v-x) / (a*a)
	
	ans = math.degrees(math.atan(num/a))
	print('{:.12g}'.format(ans))

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*(b-x/a/a)/a)))

Solution (Python):
from math import acos, sqrt, degrees
a,b,vol = map(int, input().split())

DEBUG = False
cap = a**2*b
area_tilt = vol/a

if DEBUG:
    print('vol = %d'%vol)
    print('cap = %f'%cap)
    
if vol <= cap/2:
    base = 2*area_tilt/b
    hypo = sqrt(base*base+b*b)
    deg = degrees(acos(b/hypo))
    deg_tilt = 90.0-deg
else: 
    short = b-(2*area_tilt/a - b)
    hypo = sqrt(short*short+a*a)
    deg = degrees(acos(short/hypo))
    deg_tilt = 90.0-deg

if DEBUG:
    print('short = %f'%short)
    print('hypo  = %f'%hypo)
    
print(deg_tilt)

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

import math

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

Solution (Python):
import math

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

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

Solution (Python):

import sys
import math













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

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


if __name__ == '__main__':
    main()

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

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

print(theta)

Solution (Python):
import math

a, b, x = map(int, input().split())
h = (2 * x) / (a ** 2)
A = a
B = 2*b - h

if B < b:
    print(math.degrees(math.atan2(B, A)))
else:
    print(math.degrees(math.atan2(b, (2 * x)/(a * b))))

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

import math

temp1 = (a**2 * b - x) * 2.0 / a**3

theta1 = math.degrees(math.atan(temp1))

temp2 = (a * b**2) * 1.0 / (2.0 * x)

theta2 = math.degrees(math.atan(temp2))

if a**2 * b < 2 * x:
    res = theta1
else:
    res = theta2

print(res)

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

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

print(ans)

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


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

btm = a*a
air = b * btm - x
if air > x:
  l = 0
  r = 90
  while l < r - 0.00000000001:
    mid = (l + r) / 2
    if x * 2 < a * b * b * math.tan(math.radians(90-mid)):
      l = mid
    else:
      r = mid

  print(l)

else:
  l = 0
  r = 90
  while l < r - 0.00000000001:
    mid = (l + r) / 2
    if air * 2 <= btm * a * math.tan(math.radians(90-mid)):
      l = mid
    else:
      r = mid

  print(90 - r)

Solution (Python):
import math

(a,b,x)= list(map(float,input().split()))
if x >= (a * a * b/2.0):
    print(math.degrees(math.atan(2.0 * (a * a * b - x)/ (a * a * a))))
else:  
    print(math.degrees(math.atan( (a * b *b)/(2.0 * x))))

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

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

print(ans)

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

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

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

print(Answer)

Solution (Python):
import math

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

y = x/a**2

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

print(theta)

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

bottle=(a**2)*b

if x <= bottle/2:
  
  soko=(x*2/b)/a
  
  
  r=90-(math.degrees(math.atan(soko/b)))
  
else:
  
  takasa=((a**2)*b-x)*2/(a**2)
  
  
  if takasa==0:
    r=0
  else:
      r=90-(math.degrees(math.atan(a/takasa)))

print(r)

Solution (Python):
import numpy as np
import math

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

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

import math

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

Solution (Python):
import math

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

Solution (Python):

import sys
import math
A, B, X = [float(v) for v in input().split()]

tansheeta = (2 * X) / (A * B * B)
if tansheeta > A / B:
    tansheeta = (2 * (A * A * B - X)) / (A * A * A)
    sheeta = math.atan(tansheeta)
    print(sheeta / math.pi * 180)
else:
    sheeta = math.atan(tansheeta)
    print(90 - sheeta / math.pi * 180)

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

if x>=a**2*b/2:
    c = 2*b - 2*x/a**2
    print('{:.11g}'.format(math.degrees(math.atan(c/a))))
else:
    c=2*x/(a*b)
    print('{:.11g}'.format(90.0-math.degrees(math.atan(c/b))))

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

if x==a*a*b:
    ans=0

    ans=math.degrees(ans)

    print('{:.7f}'.format(ans))
    sys.exit()
c=(2*x/a/a)-b
if c > 0:
    ans=math.atan(a/(b-c))

else:
    ans=math.atan(2*x/a/b/b)
ans=math.degrees(ans)
ans=90-ans
print('{:.7f}'.format(ans))

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

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

Solution (Python):
import math
a, b, x = map(int, input().split())
def suku(a, b, x):
    return math.atan((a*b*b)/(2*x)) * (180/math.pi)
def ooi(a, b, x):
    return math.atan((2*(a*a*b - x))/(a*a*a)) * (180/math.pi)

if a*a*b >= 2*x:
    print(suku(a, b, x))
else:
    print(ooi(a, b, x))

Solution (Python):
import math

a,b,x = map(int, input().split(' '))
menseki = a**2
taiseki = menseki * b
half = taiseki * (1/2)
sakai = half - x
nokori = taiseki - x
if sakai == 0:
    rad = math.atan(b/a)
    deg = math.degrees(rad)
elif sakai < 0:
    n =2 *  nokori / a**2
    rad = math.atan(n/a)
    deg = math.degrees(rad)
elif sakai > 0:
    ah = 2 * x / (a*b)
    rad = math.atan(b/ah)
    deg = math.degrees(rad)
print(deg)

Solution (Python):
import sys
import math


def main():
    a, b, x = [int(s) for s in sys.stdin.readline().strip().split()]
    
    
    

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

    def b_search(target, amax, hen):
        amin = 0.0
        t = amax
        s = hen * t / 2
        while abs(s - target) > 0.0000000001:
            if s > target:
                amax = t
                t = (t + amin) / 2
            else:
                amin = t
                t = (t + amax) / 2
            s = hen * t / 2
        return t

    if half < xs:
        should_removed = a * b - xs
        t = b_search(should_removed, b, a)
        cos2r = a * a / (t * t + a * a)
    else:
        t = b_search(xs, a, b)
        cos2r = t * t / (t * t + b * b)
    cosr = math.sqrt(cos2r)
    ans = math.degrees(math.acos(cosr))
    print(ans)


main()

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

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

Solution (Python):
import math

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

tan = (((a ** 2) * b - x) / (a ** 3)) * 2

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

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

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

print(theta)

Solution (Python):

import math


def solve(*args: str) -> str:
    a, b, x = map(int, args[0].split())
    ret = 0.0
    if x < a*a*b/2:
        d = (2*x)/(a*b)
        ret = math.degrees(math.atan2(b, d))
    else:
        d = ((2*x)/(a*a)) - b
        ret = math.degrees(math.atan2(b-d, a))

    return str(ret)


if __name__ == "__main__":
    print(solve(*[input() for _ in range(1)]))

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

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

Solution (Python):
import math
import sys

input = sys.stdin.readline


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


a, b, x = read_i()
if 2 * x <= a**2 * b:
    rad = math.atan2(a * b**2, 2 * x)
else:
    rad = math.atan2(2 * (a**2 * b - x), a**3)
print(rad * 180 / math.pi)

Solution (Python):
import math


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

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

print(ans)

Solution (Python):
import math

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

Solution (Python):
import math

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

Solution (Python):
import math

if __name__ == '__main__':
    a,  b, x = map(int, input().split())
    if 2.0 * (b - x / a / a) <= b:
        print(math.degrees(math.atan(2.0 * (b - x / a / a) / a)))
    else:
        print(math.degrees(math.atan((a * b * b)/2.0/x)))

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

Solution (Python):
from math import atan, degrees
a,b,x=[int(i) for i in input().split()]
x/=a
y=2*x/b

if y>a:
    c=b-(2*x-b*a)/a
    print(degrees(atan(c/a)))
    quit()

else:
    print(90-degrees(atan(y/b)))
    quit()

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

if a*b>=2*x:
    print (math.degrees(math.pi/2-math.atan(2*x/(b**2))))
else:
    y=2*x/a-b
    try:
        print(math.degrees(math.pi/2-math.atan(a/(b-y))))
    except ZeroDivisionError:
        print(0)

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

menseki=1.0*x/a
teihen=2.0*menseki/b


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

Solution (Python):
import math as m

abx = input().split(' ')
a = float(abx[0]) 
b = float(abx[1]) 
x = float(abx[2]) 
s = x / a 

if s > a * b / 2:
  Q = 2 * (a * b - s) / (a * a)
else:
  Q = (b * b) / (2 * s)

ans = m.degrees(m.atan(Q))
print(ans)

Solution (Python):
import math

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

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

if p == 0:
    print(45)
    exit()

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

Solution (Python):
import math

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

tant = 2*b/a - 2*x/a**3

if tant >= 0 and tant <= b/a:
  ans = math.atan(tant)/math.pi*180
else:
  tant = 0.5 * a*b**2/x
  ans  = math.atan(tant)/math.pi*180
  
print(ans)

Solution (Python):
from collections import Counter,defaultdict,deque
import sys,bisect,math,itertools,string,queue
from heapq import heappop, heappush
sys.setrecursionlimit(10**8)
mod = 10**9+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())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

a,b,x = inpl()

if a*a*b == x:
    print(0)
    quit()
if x/(a**2*b) <= 0.5:
    tmp = ((2*x)/(a*b)) / b
    atan1 = math.degrees(math.atan(tmp))
    print(90-atan1)
else:
    c = 2*(b-x/(a*a))
    tmp = a/c
    atan1 = math.degrees(math.atan(tmp))
    print(90-atan1)

Solution (Python):
import sys
from pprint import pprint

import math

a, b, x = map(int, sys.stdin.readline().strip().split(" "))

threshold = math.atan(b/a)


theta = math.atan(2*(a**2 * b - x) / a**3)

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

Solution (Python):
from math import tan, pi, cos, sqrt

a, b, x = map(int, input().split())
v = a*a*b
lft, rgt = 0, 180
for _ in range(100000):
    theta = (lft+rgt)/2
    height = a*tan(theta/180*pi)
    if height <= b:
        amnt = v - a*a*height/2
    else:
        c = (height - b)/tan(theta/180*pi)
        amnt = v - a*a*b/2 - a*b*c/2
    if x > amnt:
        rgt = theta
    else:
        lft = theta
print(theta)

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

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())

sys.setrecursionlimit(10 ** 9)


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

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


if __name__ == '__main__':
    main()

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

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

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

def main():
    a, b, x = [int(x) for x in input().split()]
    b_now = x / (a * a)
    menseki = b_now * a
    ans_a = menseki * 2 / b

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

    if ans_a <= a:
        z = math.degrees(math.atan(ans_a / b))
        print(90 - z)
        exit()
    else:
        menseki = a * b - menseki
        ans_b = menseki * 2 / a
        z = math.degrees(math.atan(a / ans_b))
        print(90 - z)
        exit()



if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np

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

ans=0

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

	
	
print(np.rad2deg(ans))

Solution (Python):
import math

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

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

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

print(theta)

Solution (Python):
import math

abc = input()
abc_list = abc.split(' ')
abc_intlist = []
for c1 in abc_list:
  abc_intlist.append(int(c1))
a = abc_intlist[0]
b = abc_intlist[1]
x = abc_intlist[2]
if (a**2)*b<2*x:
    print(math.degrees(math.atan(  2*(b-x/(a**2))/a  )  ))
else:
    print(math.degrees(math.atan(  a*(b**2)/(2*x)  )  ))

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import math

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

V = A * A * B

H = X / V * B
H2 = A * X / V 

lb = 0
ub = 90

def judge(s):
    global A
    global B
    global H

    if (B - H) * math.cos(s * math.pi/180) - A / 2 * math.sin(s * math.pi/180) >= 0:
        return True
    else:
        return False

def judge2(s):
    global A
    global B
    global H2

    if B/2 * math.cos(s * math.pi/180) - H2 * math.sin(s * math.pi/180) >= 0:
        return True
    else:
        return False

for i in range(100):
    mid = (lb + ub) / 2
    if judge(mid):
        lb = mid
    else:
        ub = mid

if H < B/2:
    print(math.atan(B/2/H2)*180/math.pi)
else:
    print(mid)

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

theta = 0.0
if (x <= 0.5*a*a*b):
    theta = atan(0.5*a*b*b/x)
else:
    theta = atan( 2.0*(b-x/(a*a))/a )
theta = theta * 180 / pi
print('{:.10f}'.format(theta))

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

import math

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

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

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

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


print(theta)

Solution (Python):


import numpy as np

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


lim_x = float(a*a*b) / 2.0


if( x >= lim_x ):
    
    x_non = float(a*a*b - x)
    
    tmp_b = float(2*x_non) / float(a*a)
    
    r = np.sqrt(a*a+tmp_b*tmp_b)
    
    tmp_a = a
    
    tmp_c = r
    cos_sita = (tmp_a**2+tmp_c**2-tmp_b**2) / (2*tmp_a*tmp_c)
    
    sita = np.arccos(cos_sita)
    
    print(np.rad2deg(sita))

elif( x < lim_x ):
    
    a_x = (2.0 * x) / ( a * b )
    
    scale = a_x / np.sqrt(b*b + a_x*a_x)
    
    under_a = a_x * scale
    under_b = b * scale
    
    
    tmp_a = a_x
    tmp_b = under_b
    tmp_c = under_a
    cos_sita = (tmp_a**2+tmp_c**2-tmp_b**2) / (2*tmp_a*tmp_c)
    
    sita = np.arccos(cos_sita)
    
    print(np.rad2deg(sita))

Solution (Python):
import math

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

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

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

Solution (Python):
import math
a,b,x = list(map(int, input().split()))
if x<= a**2*b/2:
    h1 = x/a /b *2
    l = math.sqrt(b**2 + h1**2)
    h2 = x/a /l *2
    
    ans = math.degrees(math.acos(h2/b))

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

print(ans)

Solution (Python):
import math

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

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

Solution (Python):
import math

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

Solution (Python):
import sys
from collections import Counter, deque, defaultdict
from math import factorial
from fractions import Fraction
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))


a, b, x = MAP()
S = Fraction(x, a)
x = Fraction(S, a)

if 2*x >= b:
    print(math.degrees(math.atan(float(Fraction((2*b - 2*x), a)))))
else:
    print(math.degrees(math.atan(float(Fraction(b**2,2*S)))))

Solution (Python):
import math

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

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

Solution (Python):

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

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

print(angle)

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

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

else:
        print(math.degrees(math.atan2(b,l2)))

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

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

Solution (Python):
import math

nums = list(map(int, input().split(" ")))

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

bottle = a * a * b

if bottle / 2.0 < x:
    temp = bottle - x
    y = temp * 2 / a / a
    result = math.degrees(math.atan(y/a))
else:
    y = x * 2 / b / a
    result = math.degrees(math.atan(b/y))

print(result)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(int(1e6))

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

import math


m = a*a*b - x

n = m / (a*a)


if n < (b / 2):    
    tan_k = n / (a/2)
else:
    
    d = 2 * x / (a * b)
    tan_k = b / d

k_rad = math.atan(tan_k)
ans = k_rad * 180 / math.pi

print(ans)

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


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


if __name__ == '__main__':
    main()

Solution (Python):
a,b,v = map(int,input().split())
import math
s = v/a
if 2*s < a*b:
  sin = b/math.sqrt((b**2)+(4*(s**2)/(b**2)))
  print(math.degrees(math.asin(sin)))
elif 2*s == a*b:
  sin = b/math.sqrt((b**2)+(a**2))
  print(math.degrees(math.asin(sin)))
else:
  sin = 2*(a*b-s)/math.sqrt(((4*((a*b-s)**2))/(a**2))+(a**2))/a
  print(math.degrees(math.asin(sin)))

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

Solution (Python):
import math

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

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

Solution (Python):
import numpy as np
a,b,x = map(int,input().split())
V = a * a * b
dV = V - x
if x == V:
  print("0")
  
elif x >= V / 2:
  h = dV / V * b * 2
  theta = np.arctan(a / h) * 360 / (2 * np.pi)
  print(90-theta)
  
else:
  h = x / V * a * 2
  theta = np.arctan(h / b) * 360 / (2 * np.pi)
  print(90-theta)

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

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