Problem:
 Score : 400 points    Problem Statement Takahashi has a water bottle with the shape of a rectangular prism whose base is a square of side a~\mathrm{cm} and whose height is b~\mathrm{cm} . (The thickness of the bottle can be ignored.)  We will pour x~\mathrm{cm}^3 of water into the bottle, and gradually tilt the bottle around one of the sides of the base.  When will the water be spilled? More formally, find the maximum angle in which we can tilt the bottle without spilling any water.      Constraints  All values in input are integers.  1 \leq a \leq 100  1 \leq b \leq 100  1 \leq x \leq a^2b         Input Input is given from Standard Input in the following format:  a  b  x       Output Print the maximum angle in which we can tilt the bottle without spilling any water, in degrees.
Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6} .        Sample Input 1 2 2 4      Sample Output 1 45.0000000000  This bottle has a cubic shape, and it is half-full. The water gets spilled when we tilt the bottle more than 45 degrees.       Sample Input 2 12 21 10      Sample Output 2 89.7834636934  This bottle is almost empty. When the water gets spilled, the bottle is nearly horizontal.       Sample Input 3 3 1 8      Sample Output 3 4.2363947991  This bottle is almost full. When the water gets spilled, the bottle is still nearly vertical.

Solution (Python):
import sys,math

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	a,b,x =MI()
	V = a*a*b
	if(V*0.5 >= x):
		t=2*x/(a*b)
		ans = 90 -math.degrees(math.atan(t/b))
	else:
		t=(2*x-(a**2)*b)/(a**2)
		t=b-t
		ans = math.degrees(math.atan(t/a))
	print(ans)
main()

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

ans_hen = x/(a*b)*2
if ans_hen < a:
    ans = math.degrees(math.atan(b/ans_hen))
else:
    ans = math.degrees(math.atan(ans_hen2/a))

print(ans)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, atan, degrees
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

rad = atan(2*(b/a-x/(a**3))) if x>=(a**2)*b/2 else atan(a*(b**2)/2/x)
print(degrees(rad))

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

Solution (Python):
import math


def main():
    a, b, x = [int(x) for x in input().split()]
    area = x / a
    if area < a*b/2:
        theta = math.pi/2 - math.atan(2*area/b/b)
    else:
        theta = math.atan((2*b-2*area/a)/a)
    theta_deg = math.degrees(theta)
    print(theta_deg)


if __name__ == "__main__":
    main()

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

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

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

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

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

ans = 0
if a * a * b / 2.0 <= 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))

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

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

Solution (Python):
import math as mt
a,b,x = [int(i) for i in input().rstrip().split(' ')]
m = x/a
if m >= a*b/2:
    T = mt.degrees(mt.atan(2*(a*b - m)/(a*a)))
else:
    T = mt.degrees(mt.atan(b*b/m*0.5))
print(T)

Solution (Python):
from math import atan2, pi

def solve(a, b, x):
    if a * a * b <= 2 * x:
        return 90 - atan2(a / 2, b - x / a / a) / pi * 180
    else:
        return 90 - atan2(2 * x / a / b, b) / pi * 180

_a, _b, _x = map(int, input().split())
print(solve(_a, _b, _x))

Solution (Python):
from math import atan2, degrees
A, B, X = map(int, input().split())
S = X / A


if S >= A * B / 2:
    h = (2 * (A * B - S)) / A
    print(degrees(atan2(h, A)))

else:
    w = (2 * S) / B
    print(degrees(atan2(B, w)))

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math
import sys
a,b,x = map(int,input().split())
if a*a*b == x:
    print(0)
    sys.exit()
tan = a**3/(2*(a**2*b-x))
if tan<=(a/b):
    tan = 2*x/(b**2*a)
rad = math.atan(tan)
deg= 90- (rad * 180/math.pi)
print(deg)

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

import math

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

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

print(90-math.degrees(theta))

Solution (Python):
import math

EPS = 0.0000000001
PI = math.pi


def f(a, b, theta):
    if theta > PI / 2.0 - EPS:
        return 0.0

    if a * math.tan(theta) <= b:
        ret = a * a * b - a * a * a * math.tan(theta) / 2.0
    else:
        ret = b * b / math.tan(theta) * a / 2.0
    return ret


a, b, x = map(int, input().split())
ok = PI / 2.0
ng = 0.0
for i in range(1, 100001):
    mid = (ok + ng) / 2.0
    if f(a, b, mid) < x:
        ok = mid
    else:
        ng = mid
print(ok / PI * 180)

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

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

print(math.degrees(theta))

Solution (Python):
import math
import os
import sys

input = sys.stdin.readline

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


def main():
    a, b, x = list(map(int, input().split()))
    area = x / a
    h = area / a
    remain = b - h
    if h >= b / 2:
        print(math.degrees(math.atan2(remain, a / 2)))
    else:
        a_dash = (2 * area) / b
        print(math.degrees(math.atan2(b, a_dash)))


if __name__ == '__main__':
    main()

Solution (Python):


import math

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

l = 0
r = math.pi/2



while r-l>10**(-10):
    z = (l+r)/2
    if b*math.tan(z)>a:
        flag = b*a**2-a**3/2/math.tan(z) > x
    else:
        flag = a*b**2*math.tan(z)/2 > x
    if flag:
        r = z
    else:
        l = z

print(90-math.degrees(l))

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math
a,b,x = map(int,input().split())
def f(t):
    t = math.radians(t)
    if a * math.tan(t) <= b:
        return a**2 * b - a**3 * math.tan(t) / 2
    else:
        return b**2 / math.tan(t) * a / 2
tmax = 90
tmin = 0
while True:
    tmid = tmin + (tmax-tmin) / 2
    if abs(f(tmid)-x) <= 10**(-9):
        break
    if f(tmid) < x:
        tmax = tmid
    else:
        tmin = tmid
print(tmid)

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

x /= a

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

Solution (Python):
import math

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

v = a * a * b
u = v - x

if x >= v / 2:
	print(math.degrees(math.atan((2 * u) / a ** 3)))
elif x < v / 2:
	print(math.degrees(math.atan((a * b * b) / (2 * x))))

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

import math

if a**2*b>=2*x:
    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):
from math import degrees
from math import atan
a,b,x = list(map(int, input().split()))
if(2 * x > a**2 * b):
  print(degrees(atan(2 * (a ** 2 * b - x) / a ** 3)))
else:
  print(degrees(atan(a * b ** 2 / 2 / x)))

Solution (Python):
from math import atan, pi

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

res = 0

if a * a * b / 2.0 <= x:
    res = atan(2 * (a * a * b - x) / (a * a * a))
else:
    res = pi / 2 - atan(2 * x / (a * b * b))

print(res * 180.0 / pi)

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

Solution (Python):
from math import atan, degrees

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

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

print(degrees(ans))

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

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

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

def f(theta):
    if math.tan(theta)<b/a:
        
        return (a*b-((a*a*math.tan(theta))/2))*a
    else:
        return (b*b/math.tan(theta)/2)*a
low=0
high=math.pi/2
while(high-low>1e-15):
    mid=(low+high)/2
    
    if f(mid)>x:
        low=mid
    else:
        high=mid
print(math.degrees(low))

Solution (Python):
from math import *

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

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

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

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

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

Solution (Python):
import math

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

S = a**2*b


if S==x:
    theta = math.pi/2


elif S/2 < x:
    theta = math.atan(a**3/(2*(S-x)))


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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

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

def LI(): return list(map(int, sys.stdin.readline().split()))

a,b,x = LI()

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

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

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    a,b,x = LI()
    t = x / (a**2)
    if t*2 >= b:
        return abs(math.degrees(math.atan2(b-t,a/2)))

    c = x / a / b * 2
    return abs(math.degrees(math.atan2(b,c)))


print(main())

Solution (Python):
from math import tan, degrees, cos, sin, atan
a, b, x = map(int, input().split())
x = x/(a**2)

if x < b/2:
  alpha = degrees(atan((b**2)/(2*a*x)))
elif x > b/2:
  alpha = degrees(atan((2*b - 2*x)/a))
else:
  alpha = degrees(atan(b/a))

print(alpha)

Solution (Python):
from math import tan, degrees, cos, sin, atan
a, b, x = map(int, input().split())
x = x/(a**2)

if x < b/2:
    alpha = degrees(atan((b**2)/(2*a*x)))
elif x > b/2:
    alpha = degrees(atan((2*b - 2*x)/a))
else:
    alpha = degrees(atan(b/a))

print(alpha)

Solution (Python):
import math

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

def calc(theta):
    h = math.tan(theta) * a
    if h <= b:
        s = 1 / 2 * a * a * h
    else:
        c = h - b
        s = 1 / 2 * a * a * h
        s = s - s * ((c / h) ** 2)
    return s

l, r = 0.0, math.pi / 2
while abs(r - l) > 1e-12:
    m = (l + r) / 2
    rem = a * a * b - calc(m)
    if rem >= x:
        l = m
    else:
        r = m
print(l * 180 / math.pi)

Solution (Python):
import math
def ints():
  return [int(x) for x in input().split()]
def ii():
  return int(input())

a, b, x = ints()
x /= a

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

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

Solution (Python):
import math


def calc(t):
    t = math.radians(t)
    if a * math.tan(t) <= b:
        return a * a * b - a * a * a * math.tan(t) / 2
    else:
        return b * b / math.tan(t) * a / 2


a, b, x = map(int, input().split(" "))
n_max = 90
n_min = 0
for _ in range(100000):
    n_mid = n_min + (n_max - n_min) / 2
    if calc(n_mid) < x:
        n_max, n_min = n_mid, n_min
    else:
        n_max, n_min = n_max, n_mid
print(n_mid)

Solution (Python):
from math import atan as arctan
from math import degrees


def main():
    a, b, x = map(int, input().split(" "))
    bottom_area = x / a
    if bottom_area >= a * b / 2:
        print(abs(degrees(arctan((2 * x / (a ** 3)) - (2 * b / a)))))
    else:
        print(90 - degrees(arctan(2 * x / a / (b ** 2))))


if __name__ == '__main__':
    main()

Solution (Python):

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

def check(t):
    if t < atan(b/a):
        s = a*a*b - a*a*a*tan(t)/2
    else:
        s = a*b*b/tan(t)/2
    return x<s

ok = 0
ng = pi/2

while ng-ok>10**-8:
    mid = (ok+ng)/2
    if check(mid):
        ok = mid
    else:
        ng = mid

print(ok*180/pi)

Solution (Python):
import math

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

if s >= a * b / 2:
    h = ((a * b - s) * 2) / a
    radian = math.atan2(h, a)
    angle = math.degrees(radian)
    print(angle)
else:
    h = 2 * s / b
    radian = math.atan2(b, h)
    angle = math.degrees(radian)
    print(angle)

Solution (Python):

import math
import fractions

def makeDivisors(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

def bitlist(x,digit):
    res = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        res[i]=now%2
        now = now >> 1
    return res

def makeNeighbor(es,n):
    nlist = [[] for i in range(n+1)]
    for i in es:
        nlist[i[0]].append(i[1])
        nlist[i[1]].append(i[0])
    return nlist
    



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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

tan_theta = 0

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

elif x < a * a * b / 2:
    tan_theta = a * b * b / (2 * x)

else:
    tan_theta = b / a

print(math.degrees(math.atan(tan_theta)))

Solution (Python):
import math

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

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

Solution (Python):
"""
import math


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

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

print(theta)
"""

from math import atan, pi

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

if x >= a * a * b / 2:
    print(atan((a*a*b-x)/(a*a*a/2))/(2 * pi)*360)
else:
    print(90 - atan(x/(a*b*b/2))/(2 * pi)*360)

Solution (Python):
import itertools
import math


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

    return a, b, x


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


if __name__ == '__main__':
    input = read()
    print(solve(*input))

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

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

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

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 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 LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

def tan(deg):
    rad = deg * math.pi / 180.
    return math.tan(rad)

def calcDiff(a, b, angle, x):
    if tan(angle) > b / a:
        res = a*b*b/(2.* tan(angle))
    else:
        res = a*a*b - a*a*a*tan(angle) / 2.
    return res - x

def main():
    a, b, x = LI()
    ok = 0
    ng = 90
    diff = calcDiff(a, b, 0, x)
    while diff > 10**(-6) or diff < 0:
        m = (ok + ng) / 2.
        diff = calcDiff(a, b, m, x)
        if diff < 0:
            ng = m
        else:
            ok = m
    print(ok)

main()

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

    d = 2*h*a/b

    sin = math.degrees(math.acos(d/((d**2+b**2)**0.5)))
    print(sin)
else:
    d = 2*(b-h)*a/a
    sin = math.degrees(math.acos(d/((d**2+a**2)**0.5)))
    print(90-sin)

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

    d = 2*h*a/b

    sin = math.degrees(math.acos(d/((d**2+b**2)**0.5)))
    print(sin)
else:
    d = 2*(b-h)*a/a
    sin = math.degrees(math.acos(d/((d**2+a**2)**0.5)))
    print(90-sin)

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

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

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

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

if x <= a*a*b/2:
  print(math.degrees(math.asin(a*b*b/((b**4)*(a**2)+4*x*x)**0.5)))
else:
  print(math.degrees(math.asin((2*a*a*b-2*x)/(a**6+4*(a*a*b-x)**2)**0.5)))

Solution (Python):
import math
a,b,x = map(int,input().split())
half = (a * a * b) / 2
p=0
if x > half:
    t = 2 * b - 2 * x / (a*a)
    x1 = a
    y1 = t
    rad = math.atan2(y1, x1)
    p = math.degrees(rad)
elif x == half:
    x1 = a
    y1 = b
    rad = math.atan2(y1, x1)
    p = math.degrees(rad)
else:
    t = 2 * x / (a*b)
    x1 = t
    y1 = b
    rad = math.atan2(y1, x1)
    p = math.degrees(rad)
print(p)

Solution (Python):
import math

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

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

print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import logging
import math

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    a, b, x = [float(x) for x in sys.stdin.readline().split()]

    logger.debug([a, b, x])

    y_0 = 2 * x / a**2
    logger.debug(y_0)

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


if __name__ == "__main__":
    resolve()




import sys
from io import StringIO
import unittest


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)

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



if x>a**2*b/2:
    tan=(2*b/a)-(2*x/(a**3))
else:
    tan=(a*b**2)/(2*x)
    
print(np.arctan(tan)*180/np.pi)

Solution (Python):
import math


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

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

print(math.degrees(math.atan(t)))

Solution (Python):
import math
a,b,x = map(int,input().split())
if a**2*b>x> (a**2)*b/2:
  tan=2*((a**2)*b-x)/(a**3)
elif x<=a*a*b/2:
  tan=a*b*b/(2*x)
elif x==a*a*b:
  tan=0
  

print(math.degrees(math.atan(tan)))

Solution (Python):
import math

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

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

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

print(theta)

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

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

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

x = x / a

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

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

Solution (Python):

import numpy as np
a, b, x = map(int, input().split())
h = (x/(a*a)-0.5*b)/0.5
if h > 0.0:
    print("%.11f"%(np.arctan((b-h)/a)*180/np.pi))
else:
    h = x/(0.5*b*a)
    print("%.11f"%(np.arctan(b/h)*180/np.pi))

Solution (Python):
import math

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

Solution (Python):
import math
from math import atan, cos, tan

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

result =0

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

print(result)

Solution (Python):
import collections
import math
import operator as op
from functools import reduce

import numpy as np
import math


def main():
    a, b, x = list(map(int, input().split()))
    if x > a**2 * b / 2:
        angle_rad = math.atan(2 * (a**2 * b - x) / a**3)
    else:
        angle_rad = math.atan(a * (b**2) / (2 * x))
    angle = angle_rad * 180 / math.pi

    print(angle)


if __name__ == '__main__':
    main()

Solution (Python):
import math
a,b,x = map(int, input().split())
if x <= a*b*a/2:
    a1 = x*2/(a*b)
    theta = math.degrees(math.atan(b/a1))
    print("%.10f"%(theta))
else:
    b1 = b-(a*a*b-x)*2/(a*a)
    theta = math.degrees(math.atan((b-b1)/a))
    print("%.10f"%(theta))

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

v = a*a*b

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

V = (a**2) * b

S = x / a


if S == (a * b):
    ans = 0.0
    print(ans)

elif S < (a*b/2):
    
    a_dash = S * 2 / b
    f = a_dash / b
    ans = math.degrees(math.atan(f))
    print(90.0 - ans)

else:
    
    bu =  (S*2)/a - b
    b_dash = b - bu
    
    S_dash = S - (a*bu)
    f = a / b_dash
    ans = math.degrees(math.atan(f))
    print(90.0-ans)

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

V = (a**2) * b

S = x / a


if S == (a * b):
    ans = 0.0
    print(ans)

elif S < (a*b/2):
    
    a_dash = S * 2 / b
    f = a_dash / b
    ans = math.degrees(math.atan(f))
    print(90.0 - ans)

else:
    
    bu =  (S*2)/a - b
    b_dash = b - bu
    
    S_dash = S - (a*bu)
    f = a / b_dash
    ans = math.degrees(math.atan(f))
    print(90.0-ans)

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

V = (a**2) * b


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

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

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
from math import atan,pi
def resolve():
    a,b,x=map(int,input().split())
    if(x<=a*a*b/2):
        print(atan((a*b*b)/(2*x))*180/pi)
    else:
        print(atan(2*(a*a*b-x)/(a**3))*180/pi)
resolve()

Solution (Python):
import sys
import math
sys.setrecursionlimit(10**6)
if sys.platform in (['ios','darwin','win32']):
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

def main():
	a, b, x = MAP()
	c = x / (a**2)
	if c >= b/2:
		d = 2*b - 2*c
		
		ans = math.degrees(math.atan(d/a))
		print(ans)
	else:
		e = 2*a*c/b
		tana = math.degrees(math.atan(e/b))
		ans = 90 - tana
		print(ans)

if __name__ == '__main__':
	main()

Solution (Python):
import math

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


l = x/(a*a)

if l<=b/2.0:
    f = b**2.0/(2.0*a*l)
else:
    f = 2.0*(b-l)/a
ans = math.degrees(math.atan(f))
print(ans)

Solution (Python):
import numpy as np

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


l = x/(a*a)

if l<=b/2.0:
    f = b**2.0/(2.0*a*l)
else:
    f = 2.0*(b-l)/a
ans = np.rad2deg(np.arctan(f))
print(ans)

Solution (Python):
import numpy as np

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


l = x/(a*a)

if l<=b/2.0:
    ans = np.rad2deg(np.arctan(b**2.0/(2.0*a*l)))
else:
    ans = np.rad2deg(np.arctan(2.0*(b-l)/a))

print(ans)