$\textit{ABC}$ is a right triangle, $90^{\circ}$ at $\mbox{B}$.

Therefore, $\angle ABC=90°$.

Point $\mbox{M}$ is the midpoint of hypotenuse $\mbox{AC}$.

You are given the lengths $\boldsymbol{AB}$ and $\mbox{BC}$. 

Your task is to find $\measuredangle MBC$  (angle $\theta^o$, as shown in the figure) in degrees.

Input Format

The first line contains the length of side $\boldsymbol{AB}$.

The second line contains the length of side $\mbox{BC}$.  

Constraints

$\textbf{0}<AB\leq100$
 
$\textbf{0}<BC\leq100$
Lengths $\boldsymbol{AB}$ and $\mbox{BC}$ are natural numbers.

Output Format

Output $\measuredangle MBC$ in degrees. 

Note: Round the angle to the nearest integer.

Examples: 

If angle is 56.5000001°, then output 57°. 

If angle is 56.5000000°, then output 57°. 

If angle is 56.4999999°, then output 56°.  

$0^\circ<\theta^\circ<90^\circ$

Sample Input
10
10

Sample Output
45°

Difficulty: MEDIUM

Solutions:
import math
ab = float(input())
bc = float(input())
print(str(int(round(math.degrees(math.atan2(ab, bc))))) + '°')


import math
(c, a) = (int(input()) for _ in range(2))
print(str(int(round(math.degrees(math.atan2(c, a))))) + '°')


from math import atan2, degrees
print('{0:.0f}°'.format(degrees(atan2(float(input()), float(input())))))


import math
ab = float(input())
bc = float(input())
ac = math.sqrt(ab * ab + bc * bc)
bm = ac / 2.0
mc = bm
b = mc
c = bm
a = bc
angel_b_radian = math.acos(a / (2 * b))
angel_b_degree = int(round(180 * angel_b_radian / math.pi))
output_str = str(angel_b_degree) + '°'
print(output_str)


import math
ab = int(input())
bc = int(input())
print('%d°' % round(math.degrees(math.atan2(ab, bc))))


from math import acos, degrees
ab = int(input())
bc = int(input())
hyp = (ab ** 2 + bc ** 2) ** 0.5
mc = hyp / 2
l = degrees(acos(bc ** 2 / (2 * mc * bc)))
h = int(l) + 0.5
if l >= h:
	print(int(h + 0.5), end='')
else:
	print(int(h - 0.5), end='')
a = '°'
print(a)


import math
ab = int(input())
bc = int(input())
ac = math.sqrt(ab ** 2 + bc ** 2)
print(str(int(round(math.degrees(math.atan2(ab, bc))))) + '°')


import math
a = int(input())
b = int(input())
c = int(math.degrees(math.atan(a / 2 / (b / 2))) + 0.5)
print(str(c) + '°')


import math
ab = int(input())
bc = int(input())
ca = math.sqrt(pow(ab, 2) + pow(bc, 2))
cm = ca / 2
alpha = math.acos(bc / ca)
fc = cm * math.cos(alpha)
fm = cm * math.sin(alpha)
bf = bc - fc
bm = math.sqrt(pow(bf, 2) + pow(fm, 2))
beta = math.acos(bf / bm)
hoek = round(beta / math.pi * 180)
print(str(hoek) + '°')


import math
ab = int(input())
bc = int(input())
a = round(math.degrees(math.atan2(ab, bc)))
print(str(a) + '°')


import cmath, math
ab = int(input())
bc = int(input())
m = complex(str(bc / 2) + '+' + str(ab / 2) + 'j')
ang = round(math.degrees(cmath.phase(m)))
print(str(ang) + '°')


import math
AB = int(input())
BC = int(input())
print('%d°' % round(math.degrees(math.atan2(AB, BC)), 0))


import math
c = int(input())
a = int(input())
print(str(int(round(math.degrees(math.atan2(c, a))))) + '°')


from math import atan2, degrees
AB = int(input())
BC = int(input())
AC = (AB ** 2 + BC ** 2) ** 0.5
MC = AC / 2
MB = (BC ** 2 - MC ** 2) ** 0.5
print(str(int(degrees(atan2(AB, BC)) + 0.5)) + '°')


from math import atan2, degrees
(AB, BC) = (int(input()), int(input()))
print(str(round(degrees(atan2(AB, BC)))) + '°')


from math import *
a = float(input())
b = float(input())
print(str(round(degrees(atan2(a, b)))) + '°')


import math
(AB, BC) = (int(input()), int(input()))
print(str(int(round(math.degrees(math.atan2(AB, BC))))) + '°')


import cmath
b = int(input())
a = int(input())
c = complex(0.5 * a, 0.5 * b)
angle = cmath.phase(c)
print('%d°' % round(angle * 180 / cmath.pi))


import math
(c, a) = (int(input()), int(input()))
rad = math.atan(c / a)
deg = math.degrees(rad)
print(round(deg), '°', sep='')


from math import *
(AB, BC) = (int(input()), int(input()))
print(str(round(degrees(atan2(AB, BC)))) + '°')


import cmath
import math
ab = int(input())
bc = int(input())
print(str(round(math.degrees(math.atan(ab / bc)))) + '°')


import math

def main():
	ab = int(input())
	bc = int(input())
	t = math.atan(ab / bc) * 180 / 3.14
	print('{}°'.format(int(round(t, 0))))
main()


import math
(AB, BC) = (int(input()), int(input()))
print('{}°'.format(round(math.degrees(math.atan2(AB, BC)))))


import math
a = float(input())
c = float(input())
print(round(math.degrees(math.atan(a / c))), '°', sep='')


import math
a = int(input())
b = int(input())
print(str(round(math.degrees(math.atan2(a, b)))) + '°')


import math
ab = int(input())
bc = int(input())
tan = float(ab / bc)
atan = math.atan(tan)
print(str(int(round(math.degrees(atan), 0))) + '°')


import cmath
import math
c = int(input())
a = int(input())
b = pow(c ** 2 + a ** 2, 1 / 2)
b2 = b / 2
C = math.atan(c / a)
c2 = pow(a ** 2 + b2 ** 2 - 2 * b2 * a * math.cos(C), 1 / 2)
B = math.acos((c2 ** 2 + a ** 2 - b2 ** 2) / 2 / c2 / a)
print(round(B * 180 / 3.14), u'°', sep='')


import math
print('%.0f°' % (math.atan(int(input()) / int(input())) * (180 / math.pi)))


AB = float(input())
BC = float(input())
import math
print(str(round(math.degrees(math.atan2(AB, BC)))) + '°')


import cmath
import math
AB = int(input())
BC = int(input())
A = complex(0, AB)
B = complex(0, 0)
C = complex(BC, 0)
MBC = int(round(math.degrees(cmath.phase(B + C + A))))
print(str(MBC) + '°')


import math
ab = int(input())
bc = int(input())
print(str(round(math.degrees(math.atan(ab / bc)))) + '°')


from math import atan, pi
Y = float(input()) / 2.0
X = float(input()) / 2.0
print('{:.0f}°'.format(atan(Y / X) * 180 / pi if X else 0.0))


import math
m = int(input())
n = int(input())
p = math.hypot(m, n) / 2
print(str(int(round(math.acos((p * p + n * n - p * p) / (2 * p * n)) * 180 / math.pi))) + '°')


import math
ab = int(input())
bc = int(input())
print(str(int(round(math.degrees(math.atan2(ab, bc))))) + '°')


import math
ab = input()
bc = input()
ab = float(ab)
bc = float(bc)
theta = math.atan(ab / bc)
theta = theta / math.pi * 180
theta = round(theta)
print(str(theta) + '°')


import math
k = int(input())
l = int(input())
j = math.hypot(k, l) / 2
print(str(int(round(math.acos((j * j + l * l - j * j) / (2 * j * l)) * 180 / math.pi))) + '°')


import math
AB = int(input())
BC = int(input())
print(str(round(math.degrees(math.atan2(AB, BC)))) + '°')


from math import degrees, atan, asin, sin, cos, sqrt
x = int(input())
y = int(input())
z = (x ** 2 + y ** 2) ** 0.5 / 2
t1 = atan(x / y)
w = sqrt(z ** 2 + y ** 2 - 2 * z * y * cos(t1))
t = round(degrees(asin(sin(t1) / w * z)))
print('{:d}°'.format(t))


import math
AB = int(input())
BC = int(input())
print(str(int(round(math.degrees(math.atan2(AB, BC))))) + '°')


import math
AB = int(input())
BC = int(input())
if 0 < AB <= 100 and 0 < BC <= 100:
	print(str(int(round(math.degrees(math.atan2(AB, BC))))) + '°')
else:
	print('Invalid input')


import math
AB = int(input())
BC = int(input())
MCB = round(math.degrees(math.atan2(AB, BC)))
print(str(MCB) + '°')


import math
(ab, bc) = (int(input()), int(input()))
angle = int(round(math.degrees(math.atan2(ab, bc))))
print('%d°' % (angle,))


import math
x = int(input())
y = int(input())
print('{}°'.format(int(round(math.degrees(math.atan2(x, y))))))


import math
a = int(input())
b = int(input())
c = math.sqrt(a * a + b * b)
e = c / 2
h = a / 2
x = b / 2
tg = h / x
x = math.atan(tg)
z = math.degrees(x)
stopien = '°'
print(round(z), stopien, sep='')


from math import degrees, atan2
a = float(input())
b = float(input())
c = degrees(atan2(a, b))
print(str(round(c)) + '°')


from math import degrees, acos
x = int(input())
y = int(input())
z = (x ** 2 + y ** 2) ** 0.5
l = z / 2
s = y / (2 * l)
s1 = degrees(acos(s))
h = s1 - 0.5 - int(s1)
if h < 0:
	print(int(s1), end='')
else:
	print(int(s1) + 1, end='')
a = '°'
print(a)


ab = int(input())
bc = int(input())
from math import atan2, degrees
mx = bc / 2
my = ab / 2
print(str(round(degrees(atan2(my, mx)))) + '°')


import math
(a, b) = (float(input()), float(input()))
d = math.degrees(math.atan(a / b))
print('{0:.0f}°'.format(d))


import math
n = int(input())
m = int(input())
a = abs(complex(n, m))
c = math.acos(m / a)
x = round(math.degrees(c))
print('%d°' % x)


from math import atan
from math import degrees

def __starting_point():
	ab = int(input().strip())
	bc = int(input().strip())
	print('{}°'.format(int(round(degrees(atan(ab / bc))))))
__starting_point()


import math
a = int(input())
b = int(input())
c = math.sqrt(a ** 2 + b ** 2)
tetha = math.asin(a / c) * 180 / math.pi
print('{:.0f}°'.format(tetha))


import cmath
import math
c = int(input())
a = int(input())
print(str(round(math.degrees(cmath.atan(c / a).real))) + '°')


from math import atan, pi
ab = int(input())
bc = int(input())

def deg(rad):
	return 180 / pi * rad
ans = deg(atan(ab / bc))
print(round(ans), u'°', sep='')


import math
degree_sign = u'°'
a = int(input())
b = int(input())
ang = math.atan2(a, b)
ang = ang / math.pi * 180.0
print('{:.0f}{}'.format(ang, degree_sign))


import math
(AB, BC) = (int(input()), int(input()))
M = math.sqrt(AB ** 2 + BC ** 2)
C = math.atan2(AB, BC)
MC = M / 2
B = math.acos(BC / 2 / MC)
print('{0:.0f}°'.format(B * (180 / math.pi)))


import math
(ab, bc) = (int(input()), int(input()))
print(round(math.degrees(math.atan(ab / bc))), '°', sep='')


import math
AB = int(input())
BC = int(input())
z = math.atan2(AB, BC)
z = math.degrees(z)
z = round(z)
z = str(z) + '°'
print(z)


import math
import decimal
ab = float(input())
bc = float(input())
print(int(round(math.degrees(math.atan(ab / bc)))), '°', sep='')


import math
print(str(int(round(math.degrees(math.atan(int(input()) / int(input())))))) + '°')


import math
a = int(input())
c = int(input())
print('{:.0f}°'.format(round(math.degrees(math.atan(a / c)))))


import math
AB = int(input().strip())
BC = int(input().strip())
print('%d°' % round(math.degrees(math.atan2(AB, BC))))


from math import sqrt, acos, degrees
ab = float(input())
bc = float(input())
ac = sqrt(ab ** 2 + bc ** 2)
m = sqrt(2 * ab ** 2 + 2 * bc ** 2 - ac ** 2) / 2
mc = ac / 2
t = m + mc + bc
phi = degrees(acos((m ** 2 + bc ** 2 - mc ** 2) / (2 * m * bc)))
print('{:.0f}°'.format(phi))


from textwrap import wrap
from cmath import phase
from math import sqrt, acos, degrees
import math

def getInt():
	return int(input())

def getFloat():
	return float(input())

def getStr():
	return input()

def getIntList(split=' '):
	return list(map(int, input().split(split)))

def printListVertical(arr):
	for x in arr:
		print(x)

def unique(arr):
	return list(set(arr))

def uniqueOrdered(arr):
	return sorted(set(arr), key=lambda x: arr.index(x))
a = getFloat()
b = getFloat()
m = sqrt(a * a + b * b)
theta = degrees(math.atan2(a, b))
theta = round(theta)
print(str(theta) + '°')


import math

def func():
	a = int(input())
	b = int(input())
	lowan = math.atan2(a, b)
	upang = math.atan2(b, a)
	hyp = abs(complex(a, b))
	print(str(int(0.5 + math.degrees(math.atan2(a - hyp * math.cos(upang) / 2, b - hyp * math.cos(lowan) / 2)))) + '°')
func()


import math
len_ab = int(input())
len_bc = int(input())
print(str(round(math.degrees(math.atan2(len_ab, len_bc)))) + '°')


import math
c = int(input())
a = int(input())
b = math.sqrt(a ** 2 + c ** 2)
angle = math.degrees(math.acos((a * a + b * b - c * c) / (2 * a * b)))
angle = int(round(angle, 0))
angle = str(angle) + '°'
print(angle)


from math import atan2, degrees
AB = int(input())
BC = int(input())
print(str(int(round(degrees(atan2(AB, BC))))) + '°')


import math
AB = float(input())
BC = float(input())
print(str(int(round(math.degrees(math.atan2(AB, BC))))) + '°')


import math
a = float(input())
b = float(input())
print(str(int(round(math.degrees(math.atan2(a, b))))) + '°')


import cmath
import math
m = int(input())
n = int(input())
c = abs(complex(m, n))
b = math.acos(n / c)
print('%d°' % round(math.degrees(b)))


import math
(AB, BC) = (int(input()), int(input()))
print(str(round(math.degrees(math.atan2(AB, BC)))) + '°')


from math import sqrt
import math
ab = int(input())
bc = int(input())
ac = sqrt(ab.__pow__(2) + bc.__pow__(2))
angle = (bc.__pow__(2) + ac.__pow__(2) - ab.__pow__(2)) / (2 * bc * ac)
finalAngle = round(math.acos(angle) * 180 / math.pi)
deg = 176
print(str(finalAngle) + chr(176))


import math
a = int(input())
b = int(input())
print(str(round(math.degrees(math.atan(a / b)))) + '°')


import math
AB = int(input())
BC = int(input())
aMCB = math.atan2(AB, BC)
MC = math.sqrt(AB ** 2 + BC ** 2) / 2
MM2 = MC * math.sin(aMCB)
M2B = BC - math.sqrt(MC ** 2 - MM2 ** 2)
theta = math.atan2(MM2, M2B)
print(str(int(round(math.degrees(theta)))) + '°')


import math
AB = int(input())
BC = int(input())
MB = math.sqrt(AB * AB + BC * BC) / 2
MC = MB
print(str(round(math.degrees(math.acos((MB * MB + BC * BC - MC * MC) / (2.0 * MB * BC))))) + '°')


from cmath import asin, pi, sqrt
a = float(input())
b = float(input())
theta = round(asin(a / sqrt(a * a + b * b)).real * 180 / pi)
print(str(theta) + '°')