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

    h = x / float(a ** 2)
    remain = b - h
    ans = math.degrees(math.atan2(remain, a/2))
    limit = math.degrees(math.atan2(h, a/2))
    
    
    
    

    if ans <= limit:
        print(ans)
    else:
        
        t = 2 * x / (b * a)
        deg = math.degrees(math.atan2(b, t))
        print(deg)


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

Solution (Python):
import math

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

h = x / a**2.0

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

print(math.degrees(theta))

Solution (Python):


import math

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

v = a * a * b

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

Solution (Python):
import sys
import math


def solve(a: int, b: int, x: int):
    V = a * a * b
    if x * 2 > V:
        y = x / (a*a*0.5) - b
        print(math.atan2(b-y, a)/math.pi*180)
    else:
        y = x / (a*b*0.5)
        print(math.atan2(b, y)/math.pi*180)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    x = int(next(tokens))  
    ans = solve(a, b, x)
    if ans is not None:
        print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
from decimal import *
import math

def main():
    a, b, x = map(int, input().split())
    if a * a * b == x:
        print(0)
        exit()
    if Decimal(a) * Decimal(b) / Decimal(2) >= Decimal(x) / Decimal(a):
        tmp = Decimal(2) * Decimal(x) / (Decimal(a) * Decimal(b))
        c = math.atan(Decimal(tmp) / Decimal(b))
        d_deg = math.degrees(Decimal(c))
        print(Decimal(90) - Decimal(d_deg))
    else:
        d = (Decimal(2) * Decimal(x) / (Decimal(a) * Decimal(a))) - Decimal(b)
        c = math.atan(Decimal(a) / (Decimal(b) - Decimal(d)))
        d_deg = math.degrees(Decimal(c))
        print(Decimal(90) - Decimal(d_deg))


if __name__ == "__main__":
    main()

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

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

Solution (Python):

import numpy as np


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

y = 2*x/(a*a) - b
if(y >= 0):
  theta = np.arctan((b-y)/a)
else:
  z = 2*x/(a*b)
  theta = np.arctan(b/z)


print("{}".format(np.rad2deg(theta)))

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


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


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x % y)


def my_index_multi(l, x):
    return [i for i, _x in enumerate(l) if _x == x]


def sosu(x):
    for i in range(2, int(sqrt(x)+1)):
        if x % i == 0:
            return False
    return True


mod = 1000000007
inf = float('INF')


def A():
    A, B = LI()

    if A >= 1 and A <= 9 and B >= 1 and B <= 9:
        print(A*B)
    else:
        print(-1)
    return




def B():
    N = II()
    if N <= 81 and N > 9:
        for i in range(2, 10):
            if N % i == 0 and N/i <= 9:
                print('Yes')
                return

    elif N > 81:
        print('No')
        return
    else:
        print('Yes')
        return
    print('No')

    return




def C():
    N = II()
    
    
    L=[]
    count=0
    for i in range(2,int(sqrt(N)+2)):  
        if N%i==0:
            L.append(N/i)
            count=1
    if count==0:
        print(N-1)
    else :
        print(int(L[-1]-2+(N/L[-1])))


            

    
   

    return




def D():
    
    a, b ,x = LI()
    BIG=a*a*b/2
    if x>BIG:
        y=2*b-(2*x/a/a)
        print(math.degrees(math.atan(y/a)))
    else:
        y=2*x/a/b
        print(math.degrees(math.atan(b/y)))
    return




def E():
    N, M = LI()
    bit_max = 1 << N
    dp = [[inf for i in range(bit_max)] for j in range(M+1)]
    dp[0][0] = 0

    for i in range(M):
        a, b = LI()

        c = LI()
        bit = 0

        for d in c:
            bit |= 1 << (d-1)

        for w in range(bit_max):

            t = w | bit
            cost = dp[i][w] + a

            dp[i+1][t] = min(dp[i+1][t], cost)

            dp[i+1][w] = min(dp[i][w], dp[i+1][w])

    print(-1) if dp[-1][-1] == inf else print(dp[-1][-1])

    return




def F():
    N, M = LI()

    value = [0] * M
    power = [0] * M
    for i in range(M):
        a, b = LI()
        value[i] = a
        c = LI()
        L = ['0'] * N
        for k in c:
            L[k - 1] = '1'
        bint = ''.join(L)
        power[i] = int(bint, 2)
    bint = ''.join(list(['1'] * N))
    dp = [inf] * (int(bint, 2)+1)
    t = 0
    cost = 0

    dp[0] = 0
    for s in range(int(bint, 2) + 1):
        for i in range(M):
            t = s | power[i]
            cost = dp[s] + value[i]
            dp[t] = min(dp[t], cost)
    print(-1) if(dp[-1] == inf) else print(dp[-1])

    return

    



def solution(S):
    
    N = len(S)

    pass



if __name__ == '__main__':
    D()

Solution (Python):
import math

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

    if x <= a*a*b*0.5:
        y = 2*x/(a*b)
        p = y/((b**2 + y**2)**0.5)
        ans = math.degrees(math.acos(p))
    elif x < a*a*b:
        k = (2*a*x - a*a*a*b)/(2*a*a*b -2*x)
        ans = math.degrees(math.atan(b/(a+k)))
    else:
        ans = 0
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

from math import atan,tan,pi

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

def max_volume(theta):
    
    theta = theta/180*pi
    if theta<atan(b/a):
        
        area = a*b-a*a*tan(theta)/2
    else:
        area = b*(b/tan(theta))/2
    return area*a

left = 0 
right = 90 
while right - left > 1e-7:
    mid = (left+right)/2
    if max_volume(mid) <= x:
        right = mid
    else:
        left = mid

answer = (left+right)/2
print(answer)

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

Solution (Python):


import math


def solve(a, b, x):
    
    area = a * b
    x = x / a
    
    if x == area:
        return 0.0
    
    if x >= area * 0.5:
        not_x = area - x
        h = 2.0 * not_x / a
        
        
        
        return math.degrees(math.atan2(h, a))
    
    h = 2.0 * x / b
    
    
    return 90.0 - math.degrees(math.atan2(h, b))

if __name__ == '__main__':
    a, b, x = map(int, input().split())

    ans = solve(a, b, x)
print(ans)

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

Solution (Python):
import math
import bisect
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
a, b, x = LI()
ans = float(0)
c = float(0)
V = (a**2)*b

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

elif x==V/2:
    c = x/(V/2)
    ans = math.degrees(math.atan(a*c/b))
else:
    c = x/(V/2)
    ans = 90 - math.degrees(math.atan(a*c/b))


print(ans)

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

if x >= (v/2):
    right = x - b*(a**2)
    left = -(a**2)/2
    y = right/left

    alpha = math.degrees(math.atan(y/a))
else:
    right = x
    left = b*a/2
    y = right/left
    alpha = math.degrees(math.atan(b/y))
    
print(alpha)

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

print(ans)

Solution (Python):
import math

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

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

print(90 - theta)

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

Solution (Python):
import math
a, b, x = map(int, input().split())
if x < a**2*b/2:
    theta = math.atan(a*b**2/2/x)/math.pi*180
else:
    theta = math.atan(2*(a**2*b-x)/(a**3))/math.pi*180
print('{:.12g}'.format(theta))

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

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

Solution (Python):
import math

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

L = a*a*b
s = x/a

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

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

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

x = x / a * 2
vx = vx / a * 2


adig = math.degrees(math.atan(
  vx / (a ** 2)
))
bdig = math.degrees(math.atan(
  (b ** 2) / x
))

if math.tan(math.radians(adig)) * a <= b:
  print(adig)
else:
  print(bdig)

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

if V == a*a*b:
    print(0)
else:    
    if V >= a * a * b / 2:
        theta = math.atan( a**3 / (2 * (a**2 * b - V)) )

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

    print(90 - theta * 180 / math.pi)

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

Solution (Python):
import math
t=input().split(' ')
a=int(t[0]);b=int(t[1]);x=int(t[2])
if x>=a**2*b*0.5:
    print(math.degrees(math.atan(2*b/a-2*x/a**3)))
else:
    print(math.degrees(math.atan(a*b**2/(2*x))))

Solution (Python):
import math
def main():
    a, b, x = [float(i) for i in input().split()]
    alpha = math.atan2(a,b)
    theta_1 = math.atan2(((2. * a**2.) * b - 2. * x), a**3.)
    theta_2 = math.atan2((b ** 2.) * a , (2.*x))
    flag = False
    if theta_1 < math.pi/2. - alpha:
        print(math.degrees(theta_1))
    else:
        print(math.degrees(theta_2))
main()

Solution (Python):
import math as m


def calc(a, b, x):
    if x > a * a * b / 2:
        y = 2 * (a * a * b - x) / a ** 3
        return m.degrees(m.atan(y))
    else:
        y = a * b * b / 2 / x
        return m.degrees(m.atan(y))


(a, b, x) = tuple([int(s) for s in input().split()])
print(calc(a, b, x))

Solution (Python):

import math

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
import math
 
def main():
    a, b, x = map(int, input().split())
    k = x / (a ** 2)
    if 2 * k > b:
        tan = 2 * (k - b) / a
        print(abs(math.degrees(math.atan(tan))))
    else:
        tan = (b ** 2) / (2 * a * k)
        print(abs(math.degrees(math.atan(tan))))
 
 
if __name__ == '__main__':
    main()

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

Solution (Python):
import math

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

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

print(math.degrees(math.atan(r)))

Solution (Python):
from sys import stdout
import math
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split()) 
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

a,b,z = inm()
if z == a*a*b:
  print(0)
  exit()
u = z/a
if u>=a*b/2:
  t = 2*(a*b-u)/(a*a)
  d = math.degrees(math.atan(t))
else:
  p = math.atan(2*u/(b*b))
  d = 90 - math.degrees(p)
print(d)

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

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

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

h = x/(a**2)

if h >= b/2:
  angle = math.atan((b-h)/(a/2))
else:
  area = a*h
  c = 2*area/b
  angle = math.atan(b/c)
print(math.degrees(angle))

Solution (Python):
import math


def main():
    a, b, x = map(int, input().split())
    y = x / a
    s = a * b
    if y == s:
        print('0.0')
    elif y >= s / 2:
        y = (a * b) - (x / a)
        b_temp = 2 * y / a
        angle = math.atan(a / b_temp)
        print(90 - math.degrees(angle))
    else:
        a_temp = 2 * y / b
        angle = math.atan(b / a_temp)
        print(math.degrees(angle))



if __name__ == '__main__':
    main()

Solution (Python):
import math
a, b, x = map(int,input().split())
sita = 0
c = 0
if x == a*b*b:
  sita = math.pi/2
elif a*a*b/2 <= x:
  c = a*a*a/2/(a*a*b-x)
  sita = math.atan(c)
else:
  c = 2*x/a/b/b
  sita = math.atan(c)
print('{:.10g}'.format(90-math.degrees(sita)))

Solution (Python):
import math



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

h = x/(a**2)
men = a*h
m = men * 2/b

if men <= a*b/2:
    rad = math.atan(b/m)
    print(math.degrees(rad))
else:
    y = 2*men/a-b
    rad = math.atan((b-y)/a)
    print(math.degrees(rad))

Solution (Python):
import math

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

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

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

if x <= a**2*b/2:
    y = 2*x/(a*b)

    theta = math.atan2(b,y)

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

    theta = math.atan2(b-y,a)
    print(math.degrees(theta))

Solution (Python):
import math

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

if x<=a*a*b/2:
    Ans=a*b*b/2/x
else:
    Ans=(2*a*b-2*x/a)/a**2

rad = math.atan(Ans)
deg = math.degrees(rad)
print(deg)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
import math

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


if __name__ == '__main__':
    main()

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

h = 2*x/(a*b)
ans1 = atan2(b, h)

y = b-x/(a*a)

if b-2*y <= 0:
    print(ans1/pi*180)
else:
    ans2 = atan2(y, a/2)
    print(ans2/pi*180)

Solution (Python):
import math
a, b, x = map(int, input().split())
if a*a*b == x:
    print(0)
    exit()
if x <= (a*a*b)/2:
    n = (2*x)/(a*b)
    s = (n**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))
else: 
    n = (2*x) / (a**2) - b
    a = (a*n) / (b-n) + a
    s = (a**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))

Solution (Python):
import math
import sys

input = sys.stdin.readline


class AtCoder:
    def main(self):
        a, b, x = map(int, input().split())
        h = x / (a * a)
        c = 2 * h - b
        if c < 0:
            e = (2 * x) / (a * b)
            tan = e / b
            print(90 - math.degrees(math.atan(tan)))
        else:
            d = b - c
            tan = d / a
            print(math.degrees(math.atan(tan)))



if __name__ == '__main__':
    AtCoder().main()

Solution (Python):
import math
a ,b ,x = list(map(int,input().split()))
if a**2 * b / 2 >= x:
    l = 2*x/a/b
    cos_m = (b**2+l**2)**(1/2)
    arccos1 = math.acos(l/cos_m)
    print(math.degrees(arccos1))
else:
    L = 2/a**2 *(a**2*b -x)
    Cos_m =(L**2 +a**2)**(1/2)
    arccos2 = math.acos(a/Cos_m)
    print(math.degrees(arccos2))

Solution (Python):
import math

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

if size > a*b/2:
    
    tan = (2*b - (2*x/a/a))/a
else:
    
    tan = (a*b*b)/2/x

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

Solution (Python):

from math import atan, pi
import sys
from collections import defaultdict

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

a, b, x = inpl()

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

if a*tand > b:
    tand = a*b*b/2/x

print(180*atan(tand)/pi)

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

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

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

all_v = a*a*b

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

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

Solution (Python):

import numpy as np


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

if b / 2 < (x / (a ** 2)):
    height = b - (x / (a ** 2))
    width = a / 2
    print(np.arctan(height / width) / (2 * np.pi) * 360)
else:
    height = b
    width = (2 * x) / (b * a)
    print(np.arctan(height / width) / (2 * np.pi) * 360)

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
from math import atan, degrees

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


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

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

import math

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

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

Solution (Python):

import sys
import math

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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    x = int(next(tokens))  
    solve(a, b, x)

if __name__ == '__main__':
    main()

Solution (Python):


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

if x >=b*a**2/2:
    h = b*2 - (2*x/a**2)
    tan = h/a
    ans = math.atan(tan)/math.pi *180
    print(ans)


else:
    w = 2*x/(a*b)
    tan = b/w
    ans = math.atan(tan)/math.pi *180
    print(ans)

Solution (Python):
import math

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

total = a**2*b

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

Solution (Python):

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

Solution (Python):
import math

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


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

print(result)

Solution (Python):
import math

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

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

    print(180/3.141592*math.atan(0.5*a*b*b/x))

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import math
import collections
import itertools
import sys
import bisect
from heapq import heappop,heappush,heapify
sys.setrecursionlimit(10**6)
def MAP(): return list(map(int,input().split()))
def INT(): return int(input())
def FLOAT(): return float(input())
MOD = 10**9+7

a,b,x = MAP()

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

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

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

Solution (Python):
import math

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

Solution (Python):


import math


def main():
  a,b,x = map(int, input().split())
  x = x/a
  l,r = 0.0,90.0
  for _ in range(10**5):
    si = (l+r)/2
    if a*math.sin(math.radians(si))/math.cos(math.radians(si)) <= b:
      v = a*b - a*a*math.sin(math.radians(si))/(2*math.cos(math.radians(si)))
    else:
      v = b*b*math.sin(math.radians(90.0-si))/(2*math.cos(math.radians(90.0-si)))
    if v >= x:
      l = si
    else:
      r = si
  return si

print(main())

Solution (Python):
import math

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

Solution (Python):
import numpy as np
a,b,x = map(int,input().split(" "))
triangle = (a*a*b)/2
if x >= triangle:
    space = a*a*b - x
    theta = np.arctan(((2*space)/(a**2))/a)
    print(np.rad2deg(theta))
else:
    water = (2*x)/(a*b)
    theta = np.arctan(b/water)
    print(np.rad2deg(theta))

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

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


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


if __name__ == '__main__':
    main()

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

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

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

l=float(2*x)/(a*b)
if l<=a:
    print 90-math.degrees( math.atan2(l,b) )
    quit()

c=float(2*x)/(a**2)-b
print math.degrees( math.atan2(b-c,a) )

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]

pi = math.pi

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

taiseki = a * a * b
shahen = math.sqrt(a*a + b*b)

def check(r):
    theta = r * pi
    t = a / math.cos(theta)

    if t <= shahen:
        hoge = taiseki - (a * a * math.tan(theta) * 0.5 * a)
        
        return x <= hoge
    else:
        theta = 0.5 * pi - theta
        s = b * math.tan(theta)
        hoge = b * s * 0.5 * a
        return x <= hoge
    


def binarySearch(small, big):
    mid = (big + small) / 2
    if big - small < 1e-9:
        return mid
    else:
        if check(mid):
            return binarySearch(mid, big)
        else:
            return binarySearch(small, mid)

ans = binarySearch(0, 0.5)

print(ans * 180)

Solution (Python):
import math

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

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

Solution (Python):
import math

def solve():
    a,b,x = map(int, input().split())
    if a*b/2*a<=x:
        return math.degrees(math.asin((b-x/a**2)*2 / (a**2 + ((b-x/a**2)*2)**2)**0.5))
    else:
        return math.degrees(math.asin(b / ((x/b/a*2)**2 + b**2)**0.5))

if __name__ == '__main__':
    print(solve())

Solution (Python):

from collections import  Counter
import numpy as np

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

ans=0

if ct>=x:
    g=(a*b*b)/(2*x)
    h=a*a*b/(2*x)
    g=np.arctan(g)*180.00/np.pi

    ans=g
else:
    q=2*b/a-(2*x/a/a/a)
    r=2-(2*x/a/a/b)
    q=np.arctan(q)*180.00/np.pi

    ans=q

print(ans)

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

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

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

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

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