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):
def main():
    from math import tan, radians
    a, b, x = (int(i) for i in input().split())

    def is_ok(d):
        if b*tan(radians(90-d)) <= a:
            area = tan(radians(90-d)) * b * b / 2.0
        else:
            area = tan(radians(d)) * a * a / 2.0
            area = a*b - area
        if x / a <= area:
            return True
        else:
            return False

    def binary_search_meguru():
        ok = 0.0
        ng = 90.0
        while abs(ng - ok) > 0.000001:
            mid = ok + (ng - ok) / 2
            if is_ok(mid):
                ok = mid
            else:
                ng = mid
        return ok

    print(binary_search_meguru())


if __name__ == '__main__':
    main()

Solution (Python):
from math import atan2, pi

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

Solution (Python):
import sys
from math import atan,pi
def main():
    input = sys.stdin.readline
    a,b,x =map(int, input().split())
    x /= a
    t = 0
    if 2*x < a * b:
        t = atan(b*b/2/x)
    elif 2*x > a * b:
        t = atan((2*a*b-2*x)/a/a)
    else:
        t = pi/4
    ans = t * 180 / pi
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

    a, b, x = 1.0, b / a, x / (a * a * b)
    x *= b

    if x * 2.0 > b:
        print(math.atan((b - x) / 0.5) * (180.0 / math.pi))
    else:
        print(90.0 - math.atan(x * 2 / (b * b)) * (180.0 / math.pi))

if __name__ == '__main__':
    main()

Solution (Python):
from fractions import gcd
from math import sqrt,asin,degrees
from collections import deque,defaultdict,Counter
from heapq import heapify,heappop,heappush
from copy import deepcopy
from itertools import accumulate,permutations
from bisect import bisect_left,bisect_right

a,b,x = map(int,input().split())
 
m = 2*x/a**2 - b
if m >= 0:
    sin = (b-m)/sqrt((b-m)**2+a**2)
    print("{:.7f}".format(degrees(asin(sin))))
else:
    sin = b/sqrt((b**2)+((2*x)/(a*b))**2)
    print("{:.7f}".format(degrees(asin(sin))))

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, atan
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
a,b,x = MAP()
if x > a * b * a / 2: 
    ans = atan((2 * b - 2 * x / pow(a, 2)) / a) * 180 / pi
    print(ans)
else:
    ans = atan(pow(b, 2) * a / 2 / x) * 180 / pi
    print(ans)

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

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

rad = math.atan2(B,A)
ans = math.degrees(rad)
print(ans)

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

div=a/b

from math import tan
from math import degrees
from math import pi

l=0
r=pi/2
for i in range(1000):
    mid=(l+r)/2
    t=tan(mid)
    if t<=div:
        f=a*b*b*t/2
    else:
        f=a*a/2*(2*b-a/t)
    if f<=x:
        l=mid
    else:
        r=mid

print(90-degrees(r))

Solution (Python):
import math

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

Solution (Python):

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

Solution (Python):
import math

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

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

print(deg)

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

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

Solution (Python):
import math
import copy
from copy import deepcopy
import sys
import fractions

from functools import reduce

import heapq
import collections
import itertools
sys.setrecursionlimit(100001)






def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList




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

total = a*a*b
flg = x > total/2

if flg:
    b_tmp = 2*(total-x)/a/a
    ans = math.degrees(math.atan(b_tmp/a))
else:
    a_tmp = 2*x/a/b
    ans = math.degrees(math.atan(b/a_tmp))

print(ans)

Solution (Python):

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

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

Solution (Python):
def ABC120_D():
    class UnionFind():
        def __init__(self, n):
            self.parent = [-1 for _ in range(n)]
            

        def find(self, x):
            
            if self.parent[x] < 0:
                return x
            else:
                self.parent[x] = self.find(self.parent[x])
                return self.parent[x]

        def unite(self, x, y):
            
            x, y = self.find(x), self.find(y)
            if x == y:
                return False
            else:
                if self.size(x) < self.size(y):
                    x, y = y, x
                self.parent[x] += self.parent[y]
                self.parent[y] = x

        def same(self, x, y):
            
            return self.find(x) == self.find(y)

        def size(self, x):
            
            x = self.find(x)
            return -self.parent[x]

        def is_root(self, x):
            
            return self.parent[x] < 0

        def roots(self):
            
            return [i for i, x in enumerate(self.parent) if x < 0]

        def members(self, x):
            
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def group_count(self):
            
            return len(self.roots())

        def all_group_members(self):
            
            return {r: self.members(r) for r in self.roots()}
    N, M = LI()
    P = [[]for _ in range(M)]
    for i in range(M):
        P[i] = LI()
    uf = UnionFind(N)
    ans = [N*(N-1)//2]*M
    for i,[a,b] in enumerate(P[M-1:0:-1]):
        
        a -= 1; b -= 1
        if uf.same(a,b):
            ans[i+1] = ans[i]
        else:
            cur = uf.size(a)*uf.size(b)
            ans[i+1] = ans[i]-cur
            uf.unite(a,b)
    for v in ans[::-1]:
        print(v)
    return

def JOI8_1():
    N = I()
    C = [I()for _ in range(N)]
    prev = C[0]
    BW = [[1,prev]]
    for i in range(1,N):
        
        if BW[-1][1]==C[i]:
            BW[-1][0] += 1
        else:
            if i%2==0:
                BW.append([1,C[i]])
            else:
                if len(BW) > 1:
                    BW[-2][0] += (BW[-1][0] + 1)
                    del BW[-1]
                else:
                    BW[0][0] += 1
                    BW[0][1] = C[i]
    ans = 0
    
    for i,s in BW:
        if s==0:
            ans += i
    print(ans)
    return
"""
8
1
0
1
1
0
0
0
1
"""


def ABC144_D():
    a, b, x = LI()
    half = a*a*b/2
    if x>=half:
        y = (half*2-x)/(a*a/2)
        deg = math.atan2(a,y)
        
        ans = 90-deg*180/math.pi
    else:
        y = x/(a*b/2)
        deg = math.atan2(b,y)
        ans = deg*180/math.pi
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque

def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**6)

if __name__ == '__main__':
    ABC144_D()
"""

"""

Solution (Python):
import math

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

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

Solution (Python):
from sys import stdin
import math

a, b, x = (int(i) for i in stdin.readline().rstrip().split())

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

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

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

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

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

Solution (Python):
import sys
import math

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


if(x > a*a*b):
    sys.exit()

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

print (s)

Solution (Python):
import math


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

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

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

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

Solution (Python):
a,b,x = [int(i) for i in input().split()]
from math import atan
from math import degrees
def deg(n):
    return degrees(atan(n))
V = a*a*b
if V/2 == x:
    xa = deg(1)
    xa = str(xa) + '0000000000'
    print(xa)
    exit()
if V/2 > x:
    xa = deg(a*b*b/(2*x))
    print(xa)
    exit()
if V/2 < x:
    xa = deg(2*(V-x)/a**3)
    print(xa)
    exit()

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

Solution (Python):


import math


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

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










def check(theta):
    theta_pi=theta*pi/180
    if a*a*b/2<=x:
        youryo=a*a*0.5*(b+b-a*tan(theta_pi))
    else:
        youryo=a*b*0.5*b/tan(theta_pi)
    
    return youryo>=x
    
top=90 
bottom=0 
while top-bottom>1e-10:
    mid=(top+bottom)*0.5
    if check(mid):
        bottom=mid
    else:
        top=mid
        
print(bottom)

Solution (Python):
from math import atan2, degrees

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

vol = a * a * b

if x * 2 <= vol:
    ans = atan2(a * b * b, 2 * x)

else:
    ans = atan2(2 * (vol - x), a ** 3)

ans = degrees(ans)
print(ans)

Solution (Python):


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

if a*a*b/2<=x:
    c=2*x/a/a-b
    theta=atan((b-c)/a)
    print(theta*180/pi)
else:
    d=a-2*x/b/a
    theta=atan(b/(a-d))
    print(theta*180/pi)

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

Solution (Python):
import sys
import math
import fractions
import itertools
from collections import deque
import copy
import bisect

MOD = 10 ** 9 + 7
INF = 10 ** 18 + 7
input = lambda: sys.stdin.readline().strip()

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

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

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

from math import atan, degrees
if x>=a*a*b/2:
    rad=atan(2/a*(b-x/a**2))
else:
    rad=atan((a*b*b)/(2*x))
print(degrees(rad))

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




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

	x = x/a
	tmp = a*b

	ans = 0
	
	if tmp/2 <= x:
		S = a*b
		tmptmp = (2*(S-x))/a
		ans = math.degrees(math.atan2(tmptmp, a))
	else:
		tmptmp = 2*x/b
		ans = math.degrees(math.atan2(b, tmptmp))
		

	print(ans)








def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

Solution (Python):
import sys
from fractions import gcd
from itertools import permutations, combinations, accumulate
from collections import deque
from heapq import heappush, heappop, heapify
from collections import deque
import math

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

MOD = 10**9 + 7

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

    ng = 90
    ok = 0

    if (a**2 * b)/2 < x:
        tan = 2 * ((b / a) - (x / a ** 3))
        while abs(ng-ok) > 10**(-7):
            mid = (ng + ok) /2
            if math.tan(math.radians(mid)) <= tan:
                ok = mid
            else:
                ng = mid
    else:
        tan = (a * b**2) / (2 * x)
        while abs(ng-ok) > 10**(-7):
            mid = (ng + ok) /2
            if math.tan(math.radians(mid)) <= tan:
                ok = mid
            else:
                ng = mid

    print(ok)



if __name__ == '__main__':
    main()

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

if a**2*b < 2*x:
    hight = (a ** 2 * b - x)/((a**2/2))
    bottom = a

else:
    hight = b

    area = a * hight

    bottom = 2 * x / area

print(math.degrees(math.atan2(hight, bottom)))

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

import math

M = A * A * B
if X >= M/2:
  m = A*A*B
  C = 2*(m-X) / (A*A)
  ans = math.atan2(C,A) / math.pi*180  
  
else:
  C = (2*X)/(A*B)
  ans = math.atan2(B,C) / math.pi*180  
  
print(ans)

Solution (Python):


def main():
    from math import pi, tan, radians

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

    def volume(theta: float):
        """傾けた直方体に存在できる水の体積
        水面を地面に対し平行にした図を描き
        tanを用いると計算できる"""
        theta = radians(theta)
        if a * tan(theta) <= b:  
            return a * a * b - a * a * a * tan(theta) / 2
        else:  
            return a * b * b * tan(pi / 2 - theta) / 2

    def is_ok(theta):
        return volume(theta) >= x

    def binary_search():
        small, large = 0, 90
        for _ in range(30):
            mid = (small + large) / 2
            if is_ok(mid):
                small = mid
            else:
                large = mid
        return small

    ret = binary_search()
    print(ret)


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
from math import atan, pi

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

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

Solution (Python):
import math

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

V = a*a*b

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

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

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

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

Solution (Python):
def main():
  a, b, x = map(int, input().split())
  vm = a*a*b
  if x==vm:
    return 0
  elif x>vm/2:
    return 90-math.degrees(math.atan(a**3/(2*(vm-x))))
  else:
    return 90-math.degrees(math.atan(2*x/(a*b*b)))

if __name__ == '__main__':
  import math
  print(main())

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [input() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [int(input()) for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def roundUp(a, b):
        return -(-a // b)

    @staticmethod
    def toUpperMultiple(a, x):
        return Math.roundUp(a, x) * x

    @staticmethod
    def toLowerMultiple(a, x):
        return (a // x) * x

    @staticmethod
    def nearPow2(n):
        if n <= 0:
            return 0
        if n & (n - 1) == 0:
            return n
        ret = 1
        while(n > 0):
            ret <<= 1
            n >>= 1
        return ret

    @staticmethod
    def sign(n):
        if n == 0:
            return 0
        if n < 0:
            return -1
        return 1

    @staticmethod
    def isPrime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


class PriorityQueue:
    def __init__(self, l=[]):
        self.__q = l
        heapq.heapify(self.__q)
        return

    def push(self, n):
        heapq.heappush(self.__q, n)
        return

    def pop(self):
        return heapq.heappop(self.__q)


sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e30)


def main():
    
    a, b, x = Scanner.map_int()
    S = x / a

    if S >= 0.5 * a * b:
        h = (a * b - S) * 2 / a
        print(math.degrees(math.atan2(h, a)))
    else:
        h = 2 * S / b
        print(math.degrees(math.atan2(b, h)))
    return


if __name__ == "__main__":
    main()

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

men = x/a
ans = 0

if men >= 0.5*a*b:
    ans = math.degrees(math.atan(2*(a*b-men)/(a*a)))
else:
    ans = 90 - math.degrees(math.atan(2*men/(b*b)))

print(ans)

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

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

if X > (A*A*B)/2:
    
    C = (X/A*2)/A-B
    print(math.degrees(math.atan((B-C)/A)))

else:
    
    H = (X/A*2)/B
    print(math.degrees(math.atan(B/H)))

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

Solution (Python):
import math

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

bottle = a * b
water = x / a

if water <= bottle / 2:
  a2 = 2 * water / b
  ans = math.degrees(math.atan(b / a2))
  
else:
  if x == a * b:
    ans = 90
  else:
    b2 = 2 * water / a - b
    water2 = water - (b2 * a)
    b3 = 2 * water2 / a
    ans = math.degrees(math.atan(b3 / a))
  
print(ans)

Solution (Python):
from math import atan, degrees

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

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

print(degrees(theta))

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

import math

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

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

Solution (Python):



from math import tan, degrees, pi

def main():
  a, b, x = map(int, input().strip().split())
  x /= a
  def bs(ltheta, rtheta):
    middle = (rtheta + ltheta) / 2
    if b - a * tan(middle) >= 0:
      v = a * (b - 0.5 * a * tan(middle))
    else:
      v = 0.5 * b * b / tan(middle)
      
    if abs(rtheta - ltheta) < 10**(-9) or v == x :
      return middle  
    if v > x:
      return bs(middle, rtheta)
    else:
      return bs(ltheta, middle)
  print(degrees(bs(0, pi/2)))

if __name__=='__main__':
  main()

Solution (Python):
import math
s = input()
ss = s.split(" ")
a = int(ss[0])
b = int(ss[1])
x = int(ss[2])

x = x/a

if(x == a*b/2):
    print("{0:.6f}".format(45))
    
elif(x > a*b/2):
    y = a*b - x
    c = y*2/a
    v = math.degrees(math.atan(c/a))
    print("{0:.6f}".format(v))
    
else:
    c = 2*x/b
    v = 90 - math.degrees(math.atan(c/b))
    print("{0:.6f}".format(v))

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

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

Solution (Python):
from math import atan


def find_angle(width, height, vol):
    area = vol/width
    if area > 1/2 * width * height:
        return atan(2*(width * height - area)/(width**2))
    else:
        return atan(height**2/(2*area))


a, b, x = [int(i) for i in input().split()]
print(find_angle(a, b, x) / (2*3.1415926535) * 360)

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

s = x / a

if s * 2 >= a * b:
  k = (2 * a * b - 2 * s) / a
  r = math.atan(k / a)
  print(math.degrees(r))

else:
  k = (2 * s) / b
  r = math.atan(b / k)
  print(math.degrees(r))

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

Solution (Python):
import math

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

if (s >= a * b / 2):
    print(math.atan2(2 * (a * b - s) / a, a) / math.pi * 180)
else:
    print(math.atan2(b, 2 * s / b) / math.pi * 180)

Solution (Python):

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

Solution (Python):
import math

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

Solution (Python):
import math

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

left = 0
right = (1/2)*math.pi
ret = left
eps = 10**(-7)
eeps = 10**(-9)

def calc_area(t):
    if t < math.atan(b/a):
        base_area = a*b
        upper = a*a*( math.tan(t) )/2
        area = base_area-upper
    else: 
        area = b*b*( math.tan(t)**(-1) )/2
    
    return area*a

ret = (right+left)/2

while True:
    diff = calc_area(ret)-x
    
    if abs(diff) < eps: break
    
    if diff < 0:
        right = ret
    else:
        left = ret
        
    ret = (right+left)/2

print(ret*(180/math.pi))

Solution (Python):





import math

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

l, r = 0.0, 90.0
if a * b / 2.0 > (x / a):
    
    while l + 10 ** (-8) < r:
        theta = (l + r) / 2.0
        
        
        
        e = b / math.tan(math.radians(theta))
        s2 = (e * b) / 2.0
        
        if s2 > (x / a):
            l = theta
        else:
            r = theta
else:
    
    while l + 10 ** (-8) < r:
        theta = (l + r) / 2.0
        
        
        
        
        s2 = (a * math.tan(math.radians(theta)) * a) / 2.0
        if (x / a) + s2 < a * b:
            l = theta
        else:
            r = theta
print(l)

Solution (Python):
import math

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

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