While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly $H$ centimeters above the water surface. Inessa grabbed the flower and sailed the distance of $L$ centimeters. Exactly at this point the flower touched the water surface. [Image] 

Suppose that the lily grows at some point $A$ on the lake bottom, and its stem is always a straight segment with one endpoint at point $A$. Also suppose that initially the flower was exactly above the point $A$, i.e. its stem was vertical. Can you determine the depth of the lake at point $A$?


-----Input-----

The only line contains two integers $H$ and $L$ ($1 \le H < L \le 10^{6}$).


-----Output-----

Print a single number — the depth of the lake at point $A$. The absolute or relative error should not exceed $10^{-6}$.

Formally, let your answer be $A$, and the jury's answer be $B$. Your answer is accepted if and only if $\frac{|A - B|}{\max{(1, |B|)}} \le 10^{-6}$.


-----Examples-----
Input
1 2

Output
1.5000000000000

Input
3 5

Output
2.6666666666667

Source: codeforces | Difficulty: EASY
Tags: Geometry

Mathematics


Solutions:
HL = list(map(int, input().split()))
H = HL[0]
L = HL[1]
x = (L ** 2 - H ** 2) / (2 * H)
print(x)


(h, l) = list(map(int, input().split()))
ans = (l ** 2 / h - h) * 0.5
print(ans)


(h, l) = map(int, input().split())
print((l * l - h * h) / (2 * h))


(h, l) = list(map(int, input().split()))
x = float((l * l - h * h) / (2 * h))
print(round(x, 6))


(H, L) = map(int, input().strip().split())
print((L * L - H * H) / (2 * H))


import math
t = 1
for _ in range(t):
	s = input().split()
	h = int(s[0])
	l = int(s[1])
	print((l * l - h * h) / (2 * h))


import sys
l = sys.stdin.readline().strip('\n').split(' ')
H = int(l[0])
L = int(l[1])
ans = (L + H) / (2 * H)
ans = ans * (L - H)
print('%.13f' % ans)


(H, L) = map(int, input().split())
a = H * H
b = L * L
print((b - a) / (2 * H))


(H, L) = list(map(int, input().split()))
print((L * L - H * H) / (2 * H))


(H, L) = list(map(int, input().split()))
Ans = (L * L - H * H) / (2 * H)
print('{0:.13f}'.format(Ans))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
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 IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def main():
	t = 1
	rr = []
	for _ in range(t):
		(h, l) = LI()
		rr.append((l ** 2 + h ** 2) / 2 / h - h)
	return JA(rr, '\n')
print(main())


a = list(map(int, input().rstrip().split()))
h = a[0]
l = a[1]
depth = (l * l - h * h) / (2 * h)
print(depth)


(h, l) = map(int, input().split())
a = (l ** 2 - h ** 2) / (2 * h)
print('%.6f' % a)


(h, l) = map(int, input().split())
m = (l ** 2 - h ** 2) / (2 * h)
print(float(m))


from math import *
(h, l) = input().split(' ')
h = float(h)
l = float(l)
x = float(sqrt(h ** 2 + l ** 2) * sin(atan(l / h)) / sin(pi - 2 * atan(l / h)) - h)
print(round(x, 13))


(H, L) = map(int, input().split())
D = (H ** 2 + L ** 2) / (2 * H)
print('%.10f' % (D - H))


(x, y) = map(float, input().split())
x1 = x * x
y1 = y * y
z = (y1 - x1) / (2 * x)
print(z)


import decimal
(x, y) = map(float, input().split())
a = y ** 2 - x ** 2
z = 2 * x
w = a / z
print(decimal.Decimal(w))


(H, L) = (int(x) for x in input().split())
print((L ** 2 - H ** 2) / (2 * H))


import math
(h, l) = [int(x) for x in input().split()]
w = math.sqrt(h * h + l * l)
cs = h / w
print(w * w / h / 2 - h)


import sys
(x, y) = list(map(int, sys.stdin.readline().strip().split()))
print((x ** 2 - y ** 2) / (-2 * x))


def toFixed(numObj, digits=0):
	return f'{numObj:.{digits}f}'
a = input().split()
c = (int(a[1]) ** 2 - int(a[0]) ** 2) / (2 * int(a[0]))
print(toFixed(c, 12))


from math import *
(H, L) = input().split()
H = int(H)
L = int(L)
D = (L ** 2 - H ** 2) / (2 * H)
print(D)


(h, l) = map(int, input().split())
ans = (h ** 2 + l ** 2) / (2 * h) - h
print('%.10f' % ans)


(H, L) = input().split()
print((int(L) ** 2 - int(H) ** 2) / (2 * int(H)))


import math
(h, l) = map(int, input().split())
small = math.atan(h / l)
big = math.atan(l / h)
rem = big - small
side = l * math.tan(rem)
print(side)


from sys import stdin
(H, L) = [int(x) for x in stdin.readline().rstrip().split()]
x = (L * L - H * H) / (2 * H)
print(x)


hl = input()
(h, l) = [int(x) for x in hl.split(' ')]
print(round((l * l - h * h) / (2 * h), 13))


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
sys.setrecursionlimit(100000000)
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
(h, l) = mul()
print((l ** 2 - h ** 2) / (2 * h))


n = input()
(h, l) = n.split(' ')
h = int(h)
l = int(l)
x = l * l / (2 * h) - h / 2
print(x)


(a, b) = map(int, input().split())
f = lambda h, l: (l ** 2 - h ** 2) / (2 * h)
print(f(a, b))


[H, L] = [int(i) for i in input().split()]
print((pow(L, 2) - pow(H, 2)) / (2 * H))


(H, L) = map(int, input().split())
answer = (L ** 2 + H ** 2) / (2 * H)
answer = answer - H
print(answer)


(h, l) = map(float, input().split())
print((l * l - h * h) / (2 * h))


(h, l) = [int(x) for x in input().split()]
ans = (pow(l, 2) - pow(h, 2)) / (2 * h)
print(ans)


from math import sqrt
(h, l) = list(map(int, input().split()))
print('{0:10.13f}'.format(-(h ** 2 - l ** 2) / (2 * h)))


(h, l) = map(int, input().split())
ans = pow(l, 2) - pow(h, 2)
print(abs(ans / (2 * h)))


a = input().split()
h = int(a[0])
l = int(a[1])
res = (l * l + h * h) / (2.0 * h)
print(res - h)


def input_to_list(inp):
	inp = inp.split(' ')
	inp = [int(i) for i in inp]
	return inp
(h, l) = input_to_list(input())
print((l ** 2 - h ** 2) / (2 * h))


from sys import stdin, stdout
from collections import Counter
import math

def rsingle_int():
	return int(stdin.readline().rstrip())

def rmult_int():
	return [int(x) for x in stdin.readline().rstrip().split()]

def rmult_str():
	return stdin.readline().rstrip().split()

def r_str():
	return stdin.readline().rstrip()

def rsingle_char():
	return stdin.read(1)
rgbs = {'R': 'RGB', 'G': 'GBR', 'B': 'BRG'}

def create_rgb(start, k):
	temp = rgbs[start]
	return temp * (k // 3) + temp[:k % 3]

def main():
	(h, l) = rmult_int()
	sin_l = math.cos(math.atan(l / h))
	x = (math.hypot(l, h) / 2 - sin_l * h) / sin_l
	print(x)
main()


(h, l) = list(map(int, input().split()))
res = (l ** 2 - h ** 2) / (2 * h)
print(res)


import math
t = list(map(int, input().split()))
val = 2 * t[0]
print((t[1] * t[1] - t[0] * t[0]) / val)


(h, l) = map(int, input().split())
print(0.5 * (l * l / h - h))


(h, l) = list(map(int, input().strip().split(' ')))
d = abs(float(l ** 2) - float(h ** 2)) / float(2 * h)
print('%.13f' % d)


from sys import stdin, stdout
(H, L) = map(float, stdin.readline().rstrip().split())
stdout.write(str((L * L - H * H) / (2 * H)))


def main():
	(h, l) = map(int, input().split())
	ans = l ** 2 - h ** 2
	print(ans / (2 * h))
main()


(h, l) = input().strip(' ').split(' ')
h = float(h)
l = float(l)
res = (l ** 2 - h ** 2) / (2 * h)
res = round(res, 12)
print(res)


(h, l) = map(int, input().split())
ans = (-h ** 2 + l ** 2) / (2 * h)
print('%.13f' % ans)


ll = lambda : list(map(int, input().split()))
testcases = 1
import math as m
for testcase in range(testcases):
	[h, l] = ll()
	x = (l * l + h * h) / (2 * h)
	print(x - h)


def main():
	a = 0
	(h, l) = map(int, input().split())
	a = (h ** 2 - l ** 2) / (-2 * h)
	print(round(a, 6))
main()


(H, L) = input().split()
H = int(H)
L = int(L)
num = L ** 2 - H ** 2
den = 2 * H
x = num / den
print('%.13f' % x)


import math
(h, l) = map(int, input().strip().split())
A = math.sqrt(h ** 2 + l ** 2)
half_A = A / 2
print(A * half_A / h - h)


from math import sqrt
(h, l) = list(map(int, input().split()))
tg_a = l / h
cos_a = sqrt(1 / (tg_a ** 2 + 1))
print(sqrt(h ** 2 + l ** 2) / 2 / cos_a - h)


a = list(map(int, input().split()))
h = a[0]
l = a[1]
if 1 <= h < l <= 10 ** 6:
	c = -(h ** 2 - l ** 2) / (2 * h)
print('%.13f' % c)


(x, y) = map(int, input().split())
e = y * y - x * x
e = e / 2
e = e / x
print(e)


from math import sqrt
(h, l) = input().split()
h = int(h)
l = int(l)
ans = (l * l - h * h) / (2 * h)
print('%.13f' % ans)


(h, l) = list(map(int, input().split()))
print('{0:10.13f}'.format(-(h ** 2 - l ** 2) / (2 * h)))


(h, l) = list(map(int, input().split()))
a = float()
if 1 <= h < l <= 10 ** 6:
	a = (l ** 2 - h ** 2) / (2 * h)
	print(a)


data = [x for x in input().split()]
ans = 0.5 * (pow(int(data[1]), 2) / int(data[0]) - int(data[0]))
print(ans)


t = input().split()
h = int(t[0])
l = int(t[1])
res = (h ** 2 + l ** 2) / (2 * h) - h
print('%.13f' % res)


import sys
input = sys.stdin.readline
(H, L) = list(map(int, input().split()))
A = (H ** 2 + L ** 2) / (2 * H)
print(A - H)


S = input('').split(' ')
H = int(S[0])
L = int(S[1])
print(abs(H * H - L * L) / (2 * H))


(h, l) = (float(i) for i in input().split())
print((l * l - h * h) / (2 * h))


l = input().split()
H = int(l[0])
L = int(l[1])
print((L ** 2 - H ** 2) / (2 * H))


(H, L) = map(int, input().split())
ans = (L ** 2 - H ** 2) / (2 * H)
print(ans)


from math import atan, tan
(h, l) = (int(s) for s in input().split())
a1 = atan(l / h)
a2 = atan(h / l)
a3 = a1 - a2
print(l * tan(a3))


(h, l) = [int(x) for x in input().split()]
result = (l ** 2 - h ** 2) / (2 * h)
print('%.12f' % result)


def main():
	(h, l) = map(int, input().split())
	x = (h ** 2 + l ** 2) / (2 * h)
	x -= h
	print(x)
	return
main()


import math
(h, l) = [int(x) for x in input().split()]
a = math.pow(l, 2)
b = math.pow(h, 2)
c = a - b
d = c / (2 * h)
print('%.13f' % d)


s = list(map(int, input().split()))
(h, l) = (s[0], s[1])
x = (l ** 2 - h ** 2) / (2 * h)
print(x)


(a, b) = map(int, input().split())
d = (b * b - a * a) / (2 * a)
print(d)


(H, L) = map(int, input().split())
d = L * L - H * H
d = d / (2 * H)
print(d)


import math

def main():
	(h, l) = map(int, input().split())
	b = math.sqrt(h ** 2 + l ** 2)
	A = math.atan(l / h)
	a = b / (2 * math.cos(A))
	print(a - h)
main()


import sys

class BWaterLily:

	def solve(self):
		(h, l) = [int(_) for _ in input().split()]
		print((l ** 2 - h ** 2) / (2 * h))
solver = BWaterLily()
input = sys.stdin.readline
solver.solve()


import sys
(h, l) = map(int, sys.stdin.readline().split())
print((l ** 2 - h ** 2) / (2 * h))


inp = [int(x) for x in input().split()]
H = inp[0]
L = inp[1]
A = (L ** 2 - H ** 2) / (2 * H)
print('{p:.7f}'.format(p=A))


(H, L) = [int(i) for i in input().split()]
num = L * L - H * H
den = 2 * H
print(num / den)


(h, l) = map(int, input().split())
a = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % a)


def pythagoras(H, L):
	return (L * L - H * H) / (2 * H)
vals = input()
inputs = vals.split(' ')
print('%.13f' % pythagoras(int(inputs[0]), int(inputs[1])))


(h, l) = map(int, input().split())
a = (l ** 2 - h ** 2) / (2 * h)
print('{0:.13f}'.format(round(a, 13)))


inp = input().split()
inp = list(map(float, inp))
h = inp[0]
l = inp[1]
a = (l * l - h * h) / (2 * h)
print(a)


L = 0
H = 0
while True:
	try:
		(H, L) = input('').split()
		L = float(L)
		H = float(H)
		if H < 1 or H > L or L > 10 ** 6:
			raise ValueError
		break
	except ValueError:
		print('invalid Values')
x = float((L ** 2 - H ** 2) / (2 * H))
print('', end='')
print('%.13f' % x)


import math
(h, l) = list(map(int, input().split()))
alpha = math.atan(l / h)
b = math.sqrt(h ** 2 + l ** 2)
x = b / (2 * math.cos(alpha))
ans = x - h
print('{:.13f}'.format(ans))


import math
(h, l) = list((int(a) for a in input().split()))
print((l ** 2 + h ** 2) ** 0.5 / (2 * math.cos(math.atan(l / h))) - h)


(H, L) = [float(x) for x in input().split()]
print(((-H) ** 2 + L ** 2) / (2 * H) - H)


(H, L) = map(int, input().split())
h = (L ** 2 - H ** 2) / (2 * H)
print(h)


(H, L) = map(int, input().split(' '))
out = (L ** 2 - H ** 2) / (2 * H * 1.0)
print('{0:.13f}'.format(out))


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
(h, l) = minput()
print(f'{(l ** 2 - h ** 2) / (2 * h):.13f}')


def water_lily(h, l):
	a = l ** 2 - h ** 2
	a = a / 2
	a = a / h
	return a
(hh, ll) = list(map(int, input().split()))
print(water_lily(hh, ll))


(h, l) = map(int, input().split())
x = l + h
y = l - h
result = x * y / (2 * h)
print(round(result, 13))


def solve():
	(h, l) = list(map(int, input().split()))
	temp = l * l - h * h
	ans = temp / (2.0 * h)
	print(ans)
solve()


(a, b) = map(int, input().split())
if 1 <= a < b <= 100 ** 6:
	print((b - a) * (b + a) / (2 * a))


x = input().split()
h = int(x[0])
l = int(x[1])
ans = h * h - l * l
ans = ans / (2 * h)
print('{0:.13f}'.format(-ans))


s = input()
for i in range(len(s)):
	if s[i] == ' ':
		h = int(s[:i])
		l = int(s[i:])
F = (l ** 2 - h ** 2) / (2 * h)
print('{:.13f}'.format(F))


hl = input().split(' ')
h = int(hl[0])
l = int(hl[1])
lsq = l * l
hsq = h * h
b = 2 * h
depth = (lsq - hsq) / b
print(depth)


(H, L) = map(int, input().split())
res = (L ** 2 - H ** 2) / (2 * H)
print(res)


[H, L] = [float(i) for i in input().split(' ')]
print((L ** 2 - H ** 2) / (2 * H))


import math
(h, l) = map(int, input().rstrip().split())
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = map(int, input().split())
a = (l * l - h * h) / (2 * h)
print('%.7f' % a)


(H, L) = map(int, input().split())
print(0.5 * (L * L - H * H) / H)


arg = input().split()
for i in range(len(arg)):
	arg[i] = int(arg[i])
(h, l) = (arg[0], arg[1])
d = float(l * l - h * h) / float(2 * h)
print(round(float(d), 15))


import math
(H, L) = map(int, input().split())
a = (L * L - H * H) / (2 * H)
print(a)


import math
(H, L) = input().split()
H = int(H)
L = int(L)
x = float((L ** 2 + H ** 2) / (2 * H))
print(x - float(H))


(n, m) = map(int, input().split())
s = (m ** 2 - n ** 2) / (2 * n)
print(s)


from math import pow
(h, l) = input().split()
h = float(h)
l = float(l)
y = pow(l, 2) / (2 * h) - h / 2
print(y)
print()


(h, l) = map(float, input().split())
ans = l * l - h * h
ans /= 2.0 * h
print(ans)


n = input().split()
H = float(n[0])
L = float(n[1])
ans = (L * L - H * H) / (2 * H)
print(ans)


line = input()
tmp = line.split(' ')
h = float(tmp[0])
l = float(tmp[1])
print((l * l - h * h) / (h * 2.0))


(h, l) = map(int, input().split())
x = (l ** 2 - h ** 2) / (2 * h)
print('%1.6f' % x)


(h, l) = list(map(int, input().split()))
d = (h + l) * (l - h) / (2 * h)
print('%.13f' % d)


(h, l) = input('').split()
a = int(h)
b = int(l)
p = (b * b - a * a) / (2 * a)
print(p)


(h, l) = map(int, input().split())
l2 = pow(l, 2)
h2 = pow(h, 2)
dif = l2 - h2
h = 2 * h
print('%.13f' % (dif / h))


(h, l) = map(int, input().split())
print(str((h ** 2 + l ** 2) ** 0.5 / 2 / (h / (h ** 2 + l ** 2) ** 0.5) - h) + '0000000000')


T = [int(x) for x in input().split()]
print((T[1] ** 2 - T[0] ** 2) / (2 * T[0]))


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s
(h, l) = mi()
x = h ** 2 + l ** 2
y = 2 * h
print(x / y - h)


import math
(h, l) = map(int, input().split())
th = math.atan(h / l)
al = 90 - math.degrees(th)
res = al - math.degrees(th)
ans = l * math.tan(math.radians(res))
print('{0:.13f}'.format(ans))


s = input()
b = s.split(' ')
h = float(b[0])
l = float(b[1])
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = map(int, input().split())
print('%.13f' % ((pow(l, 2) - pow(h, 2)) / (2 * h)))


str = list((int(x) for x in input().split()[:2]))
a = str[0]
b = str[1]
x = b * b - a * a
res = x / (2 * a)
print(res)


(h, l) = map(int, input().split())
c = (h * h + l * l) ** 0.5
a = c * c / (2 * h)
print(a - h)


(h, l) = list(map(int, input().split()))
ans = (l ** 2 - h ** 2) / (2 * h)
print(ans)


(h, l) = map(int, input().split())
x = (l ** 2 - h ** 2) / (2 * h)
print(round(x, 13))


(a, b) = map(int, input().split())
print(round((a * a + b * b) / (2 * a) - a, 15))


(H, L) = map(int, input().split())
A = (pow(L, 2) - pow(H, 2)) / (2 * H)
print(A)


(a, b) = map(int, input().split())
p = (b * b - a * a) / (2 * a)
print(str.format('{0:.13f}', p))


from math import *
from sys import *
from collections import defaultdict
M = 10 ** 9 + 7

def pow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def powmod(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a *= a
		b >>= 1
	return res

def inv(a, m):
	return powmod(a, m - 2, m)

def factor(n):
	potentional_p = 3
	itog_list = {}
	if n % 2 == 0:
		itog_list[2] = 0
	while n % 2 == 0:
		n = n // 2
		itog_list[2] += 1
	while n - 1:
		if potentional_p > n ** 0.5:
			if n in itog_list:
				itog_list[n] += 1
			else:
				itog_list[n] = 1
			return itog_list
		while n % potentional_p == 0:
			n = n // potentional_p
			if potentional_p in itog_list:
				itog_list[potentional_p] += 1
			else:
				itog_list[potentional_p] = 1
		potentional_p += 2
	return itog_list

def min1(lst):
	if len(lst) == 0:
		return 10 ** 9 + 1
	return min(lst)
(h, l) = list(map(int, stdin.readline().split()))
val = l ** 2 - h ** 2
val /= 2 * h
print(val)


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(h, l) = f()
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = list(map(int, input().split()))
ans = (h ** 2 + l ** 2) / (2 * h)
print('%0.9f' % (ans - h))


(h, l) = input().split()
h = int(h)
l = int(l)
x = (l * l - h * h) / (2 * h)
print('{0:.13f}'.format(x))


(a, b) = map(int, input().split(' '))
res = (b * b - a * a) / (2 * a)
print('%.13f' % res)


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')

def solve():
	(h, l) = mi()
	print((l * l - h * h) / (2 * h))
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
solve()


(h, l) = map(int, input().split())
from math import sqrt
print((l * l - h * h) / (2 * h))


(h, l) = map(int, input().split())
result = (l * l - h * h) / (2.0 * h)
print(result)


(h, l) = map(int, input().split())
num = l * l - h * h
den = 2 * h
ans = num / den
print('%.13f' % ans)


from sys import stdin

def problem(line):
	(x, y) = line.strip().split()
	return (int(y) ** 2 - int(x) ** 2) / (2 * int(x))

def main():
	print(problem(stdin.readline()))
main()


(h, l) = [*map(int, input().split())]
fat1 = h * h
fat2 = 2 * h
numeros = l * l - fat1
x = numeros / fat2
print('{0:.13f}'.format(x))


(h, l) = [int(i) for i in input().split()]
print((h ** 2 + l ** 2) / (2 * h) - h)


arr = list(map(int, input().split()))
h = arr[0]
l = arr[1]
p = l * l - h * h
q = 2.0 * h
r = p / q
print('{0:.13f}'.format(r))


(h, l) = [int(x) for x in input().split()]
x = (l * l - h * h) / (2 * h)
print(x)


(h, l) = map(int, input().strip().split())

def solve(h, l):
	return (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % solve(h, l))


(h, l) = list(map(int, str(input()).split()))
print('%.13f' % ((l * l - h * h) / (2 * h)))


from decimal import *
getcontext().prec = 30
(H, L) = map(int, input().split())
k = Decimal(Decimal(L ** 2 - H ** 2) / Decimal(2 * H))
print(k)


(a, b) = map(int, input().split())
print(round((a * a + b * b) / (2 * a) - a, 20))


from decimal import Decimal, getcontext
[h, l] = [int(x) for x in input().split()]
getcontext().prec = 13
print((Decimal(l ** 2) - Decimal(h ** 2)) / (2 * Decimal(h)))


(h, l) = [int(i) for i in input().split()]
num = (l + h) * (l - h)
den = 2 * h
print(num / den)


import math
(h, l) = map(int, input().split())
print(abs((h * h - l * l) / 2 / h))


(h, l) = map(int, input().split())
s = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % s)


from math import *
import sys
input = sys.stdin.readline
(h, l) = map(int, input().split())
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = [int(a) for a in input().split()]
print((l * l - h * h) / (2 * h))


(H, L) = input().split(' ')
H = float(H)
L = float(L)
d = (L ** 2 - H ** 2) / (2 * H)
print(d)


(h, l) = input().split(' ')
h = int(h)
l = int(l)
ans = (l * l - h * h) / (2 * h)
print(ans)


X = list(map(int, input().split(' ')))
print((X[1] ** 2 - X[0] ** 2) / (2 * X[0]))


import sys
from collections import defaultdict
input = sys.stdin.readline

def main():
	(H, L) = map(int, input().split())
	print((L * L - H * H) / (2 * H))
main()


import math as m
(h, l) = list(map(int, input().split()))
theta = m.degrees(m.atan(l / h))
theta2 = 90 - theta
alpha = theta - theta2
print(m.tan(m.radians(alpha)) * l)


from math import hypot
(h, l) = map(int, input().split())
x = (h ** 2 + l ** 2) / (2 * h) - h
print(x)


ints = [int(x) for x in input().split()]
H = ints[0]
L = ints[1]
m = L ** 2 - H ** 2
ans = m / (2 * H)
print(ans)


import sys
import math
input = sys.stdin.readline
(H, L) = map(int, input().split())
ans = (L ** 2 - H ** 2) / (2 * H)
print(ans)


def int_multiple():
	return [int(c) for c in input().split()]

def int_single():
	return int(input())

def str_multiple():
	return [c for c in input().split()]

def str_single():
	return input()
(h, l) = int_multiple()
k = l * l / h
d = (k - h) / 2
print(round(d, 7))


import math as m
(b, a) = map(int, input().split())
print(a / m.tan(2 * m.pi - 2 * m.atan(a / b)))


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(h, l) = I()
print((h * h + l * l) / (2 * h) - h)


(H, L) = map(int, input().split())
print('{:.13f}'.format((L * L - H * H) / (2 * H)))


import math
(h, l) = map(int, input().split())
temp = (l * l + h * h) / (2 * h)
print(temp - h)


a = list(map(int, input().rstrip().split()))
H = a[0]
L = a[1]
S = (H * H + L * L) / (2 * H)
print(S - H)


(h, l) = list(map(int, input().split()))
x = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % x)


(H, L) = [int(x) for x in input().split()]
Ans = (L ** 2 - H ** 2) / (2 * H)
print('%.10f' % Ans)


while True:
	try:
		(H, L) = map(int, input().split())
		print('%.13f' % (1.0 * (L * L - H * H) / (2 * H)))
	except:
		break


i = input()
lista_1 = i.split(' ')
H = int(lista_1[0])
L = int(lista_1[1])
A = (L ** 2 - H ** 2) / (2 * H)
print(A)


(h, l) = map(int, input().split())
m = (l ** 2 - h ** 2) / (2 * h)
print('{:.13f}'.format(m))


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for _ in range(t):
	(h, l) = map(int, input().split())
	print((l ** 2 - h ** 2) / (2 * h))


from collections import defaultdict as dd
(a, b) = [int(i) for i in input().split()]
print((b * b - a * a) / (2 * a))


(h, l) = list(map(int, input().split()))
sol = (l * l - h * h) / (2 * h)
print('%0.13f' % sol)


(n, k) = map(int, input().split())
ans = (k ** 2 - n ** 2) / (2 * n)
print('{:.15f}'.format(ans))


from sys import stdin, setrecursionlimit
from collections import deque
import math
input = stdin.readline
setrecursionlimit(int(200000.0))

def getstr():
	return input()[:-1]

def getint():
	return int(input())

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

def getint1():
	return list(map(lambda x: int(x) - 1, input().split()))
jn = lambda x, l: x.join(map(str, l))
MOD = 10 ** 9 + 7
(y, n) = ('YES', 'NO')

def solve():
	(H, B) = getints()
	h = (pow(H, 2) + pow(B, 2)) / (2 * H)
	h = h - H
	print(h)
solve()


from collections import *
(h, l) = map(int, input().split())
print((l * l - h * h) / (2 * h))


(H, L) = map(int, input().split())
x = float((L ** 2 - H ** 2) / (2 * H))
print(x)


import random
from decimal import Decimal
arr = [int(i) for i in input().split()]
H = arr[0]
L = arr[1]
HL = (H ** 2 + L ** 2) ** 0.5
print(format((L ** 2 - H ** 2) / (2 * H), '.13f'))


y = input().split(' ')
h = int(y[0])
l = int(y[1])
x = float(l * l - h * h) / (2 * h)
print('%.13f' % x)


(a, b) = [int(i) for i in input().split()]
c = float((a * a + b * b) / (2 * a)) - a
print('%.13f' % c)


from decimal import *
(h, l) = [Decimal(x) for x in input().split()]

def height(h, l):
	return (l * l - h * h) / (2 * h)
print(height(h, l))


b = list(map(int, input().split()))
h = b[0]
l = b[1]
k = l ** 2 - h ** 2
k = k / 2
k = k / h
print(k)


import sys
input = sys.stdin.readline
l = list(map(int, input().split()))
h = l[0]
l1 = l[1]
print((l1 ** 2 - h ** 2) / (2 * h))


import math
(h, l) = map(int, input().split())
c = math.pi - math.atan(l / h) * 2
print(l / math.tan(c))


(h, l) = map(int, input().split(' '))
xm = (h * h + l * l) / (2 * h)
xt = h
k = abs(xm - xt)
print('%.13f' % k)


(l, h) = input().split()
l = int(l)
h = int(h)
ans = abs(l * l - h * h) / (2.0 * l)
print(ans)


(h, l) = map(int, input().split())
a = l * l - h * h
b = 2 * h
print(a / b)


(h, l) = map(int, input().split())
ans = (l * l - h * h) / (2 * h)
print('{:0.15f}'.format(ans))


(H, L) = tuple(map(lambda x: int(x), input().split(' ')))
h = abs(L ** 2 - H ** 2) / (2 * H)
print(h)


(h, k) = input().strip().split()
(h, k) = (int(h), int(k))
print((k ** 2 - h ** 2) / (2 * h))


(x, y) = map(int, input().split())
kk = y * y - x * x
kk = kk / 2
kk = kk / x
print(round(kk, 13))


(h, l) = input().split(' ')
h = int(h)
l = int(l)
d = (l ** 2 - h ** 2) / (2 * h)
print(d)


(H, L) = list(map(int, input().split()))
R = (L ** 2 + H ** 2) / (2 * H)
print('%.7f' % (R - H))


aux = input()
aux = aux.split(' ')
aux[0] = int(aux[0])
aux[1] = int(aux[1])
resultado = (aux[1] ** 2 - aux[0] ** 2) / (2 * aux[0])
print(resultado)


(h, l) = [int(x) for x in input().split()]
a = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % a)


(H, L) = map(int, input().split())
P = (L ** 2 - H ** 2) / (2 * H)
print('%.13f' % P)


s = input().split()
h = int(s[0])
l = int(s[1])
print(0.5 * (l * l / h - h))


(h, a) = map(int, input().split())
x = (pow(a, 2) - pow(h, 2)) / (2 * h)
print(x)


(h, l) = map(int, input().split())
k = (l * l - h * h) / (2 * h)
print('{0:0.12f}'.format(k))


import math
(h, l) = input().split()
h = float(h)
l = float(l)
a = (l * l - h * h) / h / 2
print('%.6f' % a)


(h, l) = map(float, input().split())
print('{:.13f}'.format((l ** 2 - h ** 2) / (2 * h)))


string = input().split()
h = float(string[0])
l = float(string[1])
x = (l * l - h * h) / (2 * h)
print(x)


import math
from decimal import *
(h, l) = input().split(' ')
(h, l) = (int(h), int(l))
depth = (l * l - h * h) / (2 * h)
print(depth)


import math as mt
import collections as cc
import sys
I = lambda : list(map(int, input().split()))
(h, l) = I()
print(abs(h ** 2 - l ** 2) / (2 * h))


import sys
import math

def inp():
	p = sys.stdin.readline()
	return p
(h, l) = list(map(int, inp().split()))
p = pow(l, 2) - pow(h, 2)
q = 2 * h
p = p / q
print(p)


(h, l) = list(map(int, input().split()))
a = (l ** 2 - h ** 2) / (2 * h)
print(a)


import math
n = input()
(h, l) = n.split(' ')
h = int(h)
l = int(l)
val = l * l - h * h
val = val / (2 * h)
print(val)


(h, l) = map(int, input().split())
d = l ** 2 - h ** 2
x = d / (2 * h)
print(x)


def mp():
	return map(int, input().split())
(h, l) = mp()
print((l * l - h * h) / h / 2)


(H, L) = map(int, input().split())
H += 0.0
x = (H * H + L * L) / (2 * H)
depth = str(x - H)
t = depth.index('.')
n = 13 - len(depth[t + 1:])
print(depth + n * '0')


(H, L) = map(int, input().split())
x = (L ** 2 - H ** 2) / 2 / H
print('{0:.13f}'.format(x))


import math
(h, l) = [int(x) for x in input().split(' ')]
ans = (l * l - h * h) / (2 * h)
num = float('%0.13f' % ans)
print(num)


def solve(h, l):
	return (l ** 2 - h ** 2) / (2 * h)
(h, l) = [int(s) for s in input().split(' ')]
out = solve(h, l)
print('{}'.format(out))


(h, l) = map(int, input().split())
a = (h ** 2 + l ** 2) / (2 * h)
ans = str(a - h).split('.')
if len(ans[1]) < +13:
	ans[1] += '0' * (13 - len(ans[1]))
else:
	ans[1] = ans[1][:13]
print('.'.join(ans))


def main():
	(h, l) = input().split()
	h = int(h)
	l = int(l)
	print((l * l - h * h) / (2 * h))
main()


nr = input().split()
H = int(nr[0])
L = int(nr[1])
res = (L * L - H * H) / (2 * H)
print(res)


import math
(h, l) = map(int, input().split())
ang = math.atan(l / h)
ang1 = math.radians(90) - ang
myang = ang - ang1
A = l * math.tan(myang)
print(A)


(H, L) = map(int, input().rstrip().split())
ans = 0
L = L * L
ans = H * H
ans = L - ans
ans = ans / (2 * H)
print(ans)


input_1 = input()
input_2 = input_1.split(' ')
H = int(input_2[0])
L = int(input_2[1])
ans = (L * L - H * H) / (2 * H)
print(ans)


import math
import os
import random
import re
import sys
import heapq
(h, l) = map(int, input().split())
print((l + h) * (l - h) / (2 * h))


(h, l) = map(float, input().split())
r = (l * l - h * h) / (2 * h)
print(r, '\n')


(h, l) = input().split(' ')
a = int(h)
b = int(l)
x = (b * b - a * a) / (2 * a)
print(x)


import itertools

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

def output_list(v):
	print(' '.join((str(x) for x in v)))

def main():
	(h, l) = input_ints()
	print((h ** 2 + l ** 2) / (2 * h) - h)
main()


(h, l) = input().split(' ')
h = float(h)
l = float(l)
ans = (l * l - h * h) / (2 * h)
print(ans)


x = [int(i) for i in input().split()]
h = x[0]
l = x[1]
g = l ** 2 - h ** 2
g /= 2 * h
print(g)


(h, l) = map(int, input().strip().split(' '))
p = l * l - h * h
p = p / (2 * h)
print(p)


(h, l) = map(int, input().split())
print('{:.10f}'.format((pow(l, 2) - pow(h, 2)) / (2 * h)))


a = [int(a) for a in input().split()]
b = a[0]
c = a[1]
d = (c ** 2 - b ** 2) / (2 * b)
print(d)


t = list(map(int, input().split(' ')))
h = t[0]
l = t[1]
f = abs(l ** 2 - h ** 2)
f = f / (2 * h)
print('%.14f' % f)


(h, l) = list(map(float, input().split()))
r = (l * l - h * h) / (2 * h)
print(r)


(H, L) = (*map(float, input().split()),)
print((L * L - H * H) / (2 * H))


(H, L) = input().split()
y = (int(H) ** 2 + int(L) ** 2) ** 0.5
print(y ** 2 / (2 * int(H)) - int(H))


(a, b) = input().split()
a = float(a)
b = float(b)
x = float((b ** 2 - a ** 2) / (2 * a))
print(x)


m = input().split()
h = int(m[0])
l = int(m[1])
s = l ** 2 + h ** 2
s = s / (2 * h)
print(s - h)


[h, l] = [float(x) for x in input().split()]
print((l ** 2 - h ** 2) / (2.0 * h))


(h, l) = [int(i) for i in input().split()]
a = l * l - h * h
r = a / (2 * h)
print(r)


from math import *
(h, l) = [int(i) for i in input().split()]
arc = atan(l / h)
sina = sin(arc)
sinb = sin(pi - 2 * arc)
x = round(sina * sqrt(h ** 2 + l ** 2) / sinb, 9)
print(x - h)


from sys import stdin
input = stdin.readline
(H, L) = [int(i) for i in input().split()]
print((L ** 2 - H ** 2) / (2 * H))


(H, L) = map(int, input().split())
d = float((L * L - H * H) / (2 * H))
print('%.14f' % d)


import math
(h, l) = map(int, input().split())
x = (math.pow(l, 2) - math.pow(h, 2)) / (2 * h)
print(x)


import math
x = input().split()
h = int(x[0])
l = int(x[1])
print(0.5 * (l * l - h * h) / h)


from sys import stdin, stdout
intn = lambda : int(stdin.readline())
strs = lambda : stdin.readline()[:-1]
lstr = lambda : list(stdin.readline()[:-1])
mint = lambda : map(int, stdin.readline().split())
lint = lambda : list(map(int, stdin.readline().split()))
out = lambda x: stdout.write(str(x) + '\n')
out_ = lambda x: stdout.write(str(x) + ' ')

def main():
	(h, l) = mint()
	a = (l * l - h * h) / (2 * h)
	out(a)
main()


(a, b) = input().split(' ')
a = int(a)
b = int(b)
A = b * b - a * a
B = 2 * a
k = A / B
print(k)


(h, l) = [int(i) for i in input().split()]

def toFixed(numObj, digits=0):
	return f'{numObj:.{digits}f}'
res = (l ** 2 - h ** 2) / (2 * h)
print(toFixed(res, 8))


from math import *
from collections import *

def getl(t=int):
	return [t(x) for x in input().split()]

def get(t=int):
	return t(input())
alphabet = [chr(x) for x in range(ord('a'), ord('z') + 1)]
a = getl()
h = a[0]
l = a[1]
ans = l * l - h * h
ans /= 2 * h
print(ans)


N = list(map(int, input().split()))
k = N[1] ** 2 - N[0] ** 2
p = k / (2 * N[0])
print(p)


import math

def get_int_vector():
	return [int(x) for x in input().split()]
(h, l) = get_int_vector()
a = math.atan(l / h)
b = a - math.atan(h / l)
res = l * math.tan(b)
print('{:.7f}'.format(res))


(H, L) = map(float, input().split())
ans = (L ** 2 - H ** 2) / (2 * H)
print('{:.10f}'.format(ans))


(h, l) = [int(num) for num in input().split()]
c = l ** 2
c1 = h ** 2
c3 = 2 * h
ans = (c - c1) / c3
print(ans)


(H, L) = map(float, input().split())
print('{0:.13f}'.format((L ** 2 - H ** 2) / (2 * H)))


from sys import stdin, stdout

def solve(inp, out):
	(h, l) = map(int, inp().split())
	d = (l ** 2 - h ** 2) / (2 * h)
	print(d)

def main():
	inp = stdin.readline
	out = stdout.write
	t = 0
	if t == 0:
		test = 1
	else:
		test = int(inp())
	for _ in range(test):
		solve(inp, out)
main()


hl = input().split()
h = int(hl[0])
l = int(hl[1])
print((l * l + h * h) / (2 * h) - h)


def findheight(h, l):
	return (l ** 2 - h ** 2) / (2 * h)
(h, l) = map(int, input().split())
print(findheight(h, l))


from sys import stdin, stdout
(H, L) = [int(x) for x in stdin.readline().split()]
ans = float(L * L - H * H) / (2 * H)
print(ans)


(H, L) = map(int, input().split())
X = (L * L - H * H) / (2 * H)
print(X)


(h, l) = map(int, input().split())
sq = abs((-l ** 2 + h ** 2) / (2 * h))
print(sq)


(h, l) = map(int, input().split())
diff = l * l - h * h
div = 2 * h
print(diff / div)


def res():
	(h, l) = map(int, input().split())
	r = l ** 2 - h ** 2
	j = 2 * h
	print(round(r / j, 13))
res()


(a, b) = input().split()
a = int(a)
b = int(b)
print((b ** 2 - a ** 2) / (2 * a))


(h, l) = map(int, input().split())
z = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % z)


import os
import sys
import string
import math

def main(h, l):
	return (l ** 2 - h ** 2) / 2 / h

def parse():
	(h, l) = input().split(' ')
	(h, l) = (int(h), int(l))
	return (h, l)

def output(ans):
	print(ans)
output(main(*parse()))


s = input()
s = s.split()
h = int(s[0])
l = int(s[1])
x = (l * l - h * h) / (2 * h)
print(x)


from decimal import *
(h, l) = map(int, input().split())
z = Decimal(l ** 2) / Decimal(h)
y = Decimal(z) - Decimal(h)
q = Decimal(y) / Decimal(2)
print(q)


a = input().split()
h = float(a[0])
l = float(a[1])
a = (l ** 2 - h ** 2) / (2 * h)
print(a)


import sys
import os
from io import IOBase, BytesIO

def main():
	(h, l) = get_ints()
	from math import atan2, pi, tan
	ang = atan2(l, h)
	ang = pi - 2 * ang
	print(l / tan(ang))
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		py2 = round(0.5)
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2 == 1:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

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

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

def input():
	return sys.stdin.readline().strip()
main()


(H, L) = [int(x) for x in input().split()]
ans = (L * L / H - H) / 2
ans1 = (L ** 2 - H ** 2) / (2 * H)
print(ans1)


from sys import stdin

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())
(h, l) = mi()
p = l * l - h * h
print(p / (2 * h))


(h, l) = map(int, input().split())
ans = abs(l ** 2 - h ** 2)
final_ans = ans / (2 * h)
print('%.13f' % final_ans)


(H, L) = map(int, input().split())
R = (L ** 2 + H ** 2) / (2 * H)
print(R - H)


(h, l) = [int(i) for i in input().split()]
x = (l ** 2 - h ** 2) / (2 * h)
print('{:.13f}'.format(x))


import sys
Input = lambda : map(int, input().split())
(H, L) = Input()
print((L ** 2 - H ** 2) / (2 * H))


n = list(map(int, input().split()))
print((n[1] ** 2 / n[0] - n[0]) / 2)


n = input().split(' ')
n = [int(a) for a in n]
b = (n[1] ** 2 - n[0] ** 2) / (2 * n[0])
print(b)


a = [float(x) for x in input().split()]
print((a[1] * a[1] - a[0] * a[0]) / (2 * a[0]))


(h, l) = [float(x) for x in input().split()]
print(round(((2 * l) ** 2 / 4 / h + h) / 2 - h, 6))


import math
(h, l) = map(int, input().split())
diff = l * l - h * h
diff = diff / (2 * h)
print(diff)


(h, l) = map(int, input().split())
a = l ** 2 - h ** 2
print(round(a / (2 * h), 12))


def main():
	(h, l) = list(map(int, input().split()))
	print((l ** 2 - h ** 2) / (2 * h))
main()


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


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
(h, l) = map(int, input().split())
ans = (l * l - h * h) / (2 * h)
print('%.13f\n' % ans)


(h, l) = list(map(int, input().split()))
x = (pow(l, 2) + pow(h, 2)) / (2 * h)
print(x - h)


(H, L) = tuple(map(int, input().split()))
print((L - H) * (L + H) / (2 * H))


(h, l) = input().split()
H = float(h)
L = float(l)
d = (L ** 2 - H ** 2) / (2 * H)
print(format(d, '.13f'))


x = list(map(int, input().split(' ')))
print((x[1] ** 2 - x[0] ** 2) / (2 * x[0]))


import math
(H, L) = [int(x) for x in input().split(' ')]
alpha = math.atan(L / H)
beta = math.pi - 2 * alpha
line = math.sqrt(H ** 2 + L ** 2)
res = line * math.sin(alpha) / math.sin(beta)
print(res - H)


(h, l) = map(int, input().split())
(up, down) = (l * l - h * h, 2 * h)
print(f'{up / down:.13f}')


(h, l) = map(int, input().split())
print(round((l * l - h * h) / (2 * h), 9))


str = input().split()
(h, l) = (int(str[0]), int(str[1]))
k = l * l - h * h
j = 2 * h
ans = k / j
print('%.13f' % ans)


(h, l) = map(int, input().split())
t = (l * l - h * h) / (h * 2.0)
print(t)


raw_hl = input().split()
[h, l] = [int(x) for x in raw_hl]
check = (h ** 2 + l ** 2) / (2 * h) - h
print(check)


(h, l) = map(float, input().strip().split())
ans = (l - h) * (l + h) / (2 * h)
print(ans)


def waterlily(h, l):
	a = (l ** 2 - h ** 2) / (2 * h)
	return a

def main():
	(val1, val2) = map(str, input().split())
	print(waterlily(int(val1), int(val2)))
main()


line = input().split(' ')
h = float(line[0])
l = float(line[1])
x = (pow(h, 2) - pow(l, 2)) / (-2 * h)
print(str(x))


a = input().split()
h = int(a[0])
l = int(a[1])
d = l * l - h * h
p = 2 * h
m = d / p
print(m)


m = list(map(int, input().split()))
h = m[0]
l = m[1]
print((l ** 2 - h ** 2) / (2 * h))


import math
(h, l) = input().split()
h = int(h)
l = int(l)
a = float((pow(l, 2) - pow(h, 2)) / (2 * h))
print(a)


l = input()
k = []
k = l.split()
h = int(k[0])
l = int(k[1])
a = (l ** 2 - h ** 2) / (2 * h)
print(a)


x = input()
(p, q) = x.split(' ')
a = int(p)
b = int(q)
result = (b * b - a * a) / (2 * a)
print('{0:.10f}'.format(result))


(h, l) = [int(x) for x in input().split()]
a = (l * l - h * h) / (2.0 * h)
print(a)


(h, l) = map(int, input().split(' '))
x = l * l - h * h
x = float(x / (2 * h))
print(x)


l = list(map(int, input().split(' ')))
H = l[0]
L = l[1]
d = (L ** 2 - H ** 2) / (2 * H)
print(d)


import math
(h, l) = map(float, input().split())
alpha = math.atan(l / h)
edge = math.sqrt(h ** 2 + l ** 2) / 2
res = edge / math.cos(alpha)
print(res - h)


(h, l) = map(float, input().split())
ans = (l * l - h * h) / (2 * h)
print('%.10f' % ans)


import math
(h, l) = [float(item) for item in input().split()]
print((h * h + l * l) / (2 * h) - h)


import sys, heapq, math
from collections import deque, defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
DBG = True
R = 10 ** 9 + 7

def ddprint(x):
	if DBG:
		print(x)
(h, l) = inm()
print((l * l - h * h) / (2 * h))


str1 = input().split()
x = int(str1[0])
y = int(str1[1])
print((y * y - x * x) / 2 / x)


from sys import stdin
(h, l) = map(int, stdin.readline().strip().split())
x = l * l - h * h
x = x / (2 * h)
print(x)


import sys
in_file = sys.stdin
(h, l) = map(int, in_file.readline().strip().split())
sys.stdout.write(str((l * l - h * h) / (2 * h)))
sys.stdout.flush()


from sys import stdin, stdout
(h, l) = map(int, input().split())

def solve(l, h):
	return l * l / (2 * h) - h / 2
stdout.write(str(solve(l, h)))


import sys
import os
from io import BytesIO, IOBase

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

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

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
for _ in range(1):
	(h, l) = mi()
	print((l ** 2 - h ** 2) / (2 * h))


(h, l) = map(int, input().split())
b = pow(l, 2) - pow(h, 2)
a = b / (2 * h)
print(a, end='')


(h, l) = input().split()
h = int(h)
l = int(l)
x = (l * l - h * h) / (2 * h)
print('{0:.13f}'.format(round(x, 13)))


(h, l) = map(float, input().strip().split(' '))
s = (pow(l, 2) - pow(h, 2)) / (2 * h)
print('{:.8f}'.format(s))


(h, l) = input().strip().split(' ')
h = int(h)
l = int(l)
print((l ** 2 - h ** 2) / (2 * h))


import sys
data = [float(x) for x in sys.stdin.readline().strip().split()]
print((data[1] ** 2 - data[0] ** 2) / (data[0] * 2))


t = 1

def solve(h, l):
	ans = l * l - h * h
	return ans / (2 * h)
for i in range(t):
	(h, l) = map(int, input().split())
	print(solve(h, l))


def main():
	a = input().split(' ')
	H = int(a[0])
	L = int(a[1])
	print((L * L - H * H) / (2 * H))
main()


(H, L) = map(float, input().split())
D = H / 2.0
D = L / 2.0 * (L / H) - D
print(D)


import math
(H, L) = [int(x) for x in input().split()]
base = (H ** 2 + L ** 2) ** (1 / 2)
theta = math.atan(L / H)
hyp = base / 2 / math.cos(theta)
print(hyp - H)


(h, l) = map(float, input().split())
x = (pow(l, 2) - pow(h, 2)) / (2 * h)
print(f'{x:.15f}')


(a, b) = list(map(int, input().split()))
ans = pow(b, 2) - pow(a, 2)
ans = ans / a
ans = ans / 2
print('%.10f' % ans)


(H, L) = tuple(map(int, input().split()))
x = (L ** 2 - H ** 2) / (2 * H)
print('{:.13f}'.format(x))


import math
(h, l) = map(int, input().split())
p = math.sqrt(h * h + l * l)
ang = math.atan(l / h)
print(p / (2 * math.cos(ang)) - h)


temp = input()
s = temp.split(' ')
h = int(s[0])
l = int(s[1])
print((l * l - h * h) / (2 * h))


x = list(map(int, input().split()))
t = (x[1] ** 2 + x[0] ** 2) / (2 * x[0])
a = t - x[0]
print('{0:.13f}'.format(a))


from math import sqrt, pow

def readinput():
	st = input('')
	(h, l) = st.split(' ')
	return (float(h), float(l))

def solver(h, l):
	num = pow(l, 2) + pow(h, 2)
	dem = 2 * h
	return num / dem - h
(h, l) = readinput()
print(solver(h, l))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
(h, l) = L()
print((l ** 2 - h ** 2) / (2 * h))


import sys
input = sys.stdin.readline
(h, l) = map(int, input().split())
x = (l * l - h * h) / (2 * h)
print(x)


(H, L) = map(int, input().split(' '))
cotan = H / L
print(-L * (cotan ** 2 - 1) / (2 * cotan))


(h, l) = [int(x) for x in input().split()]
f = float((l * l - h * h) / (2 * h))
print(f)


(h, l) = input().split()
h = int(h)
l = int(l)
a = l ** 2 - h ** 2
b = 2 * h
s = a / b
print(s)


(h, l) = list(map(int, input().split()))
y = 2 * h
x = (l * l - h * h) / y
print('%.6f' % x)


nums = [int(i) for i in input().split(' ')]
nm = (nums[1] * nums[1] - nums[0] * nums[0]) / (2 * nums[0])
nm = round(nm, 10)
print(nm)


import sys
inf = float('inf')
mod = 1000000007

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

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

def input():
	return sys.stdin.readline()

def int1():
	return int(input())
import string
import math
from itertools import combinations

def main():
	(h, x) = get_array()
	print((x ** 2 - h ** 2) / (2 * h))
main()


(H, L) = map(float, input().split())
print('%.9f' % ((H * H + L * L) / (H * 2.0) - H))


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
infinite = float('inf')
(H, L) = RI()
print((L * L - H * H) / (2 * H))


(h, l) = map(int, input().split())
a = (l ** 2 - h ** 2) / (2 * h)
print(round(a, 7))


import sys, itertools, math

def ia():
	return [int(i) for i in sys.stdin.readline().strip().split(' ')]

def ii():
	return int(sys.stdin.readline().strip())
(H, L) = ia()
D = (L * L - H * H) / (2 * H)
print(D)


x = input()
y = x.split()
h = int(y[0])
l = int(y[1])
t = l ** 2 - h ** 2
u = 2 * h
a = float(t / u)
print(a)


for _ in range(1):
	(h, l) = map(int, input().split())
	print((l * l + h * h) / (2 * h) - h)


t = 1
for test in range(t):
	(h, l) = map(int, input().split())
	print((pow(l, 2) - pow(h, 2)) / (2 * h))


import math
(h, l) = map(int, input().split())
d1 = (l * l - h * h) / (2 * h)
print(d1)


(h, l) = input().split()
l = float(l)
h = float(h)
a = (h * h + l * l) / (2 * h) - h
print('%.15f' % a)


s = input()
P = s.split(' ')
h = float(P[0])
l = float(P[1])
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = map(int, input().split())
print(format((-h ** 2 + l ** 2) / (2 * h), '.7f'))


(x, y) = map(int, input().split())
ans = (y * y - x * x) / (2 * x)
print(ans)


(h, n) = map(int, input().rstrip().split(' '))
print((n * n - h * h) / (2 * h))


import sys
import math
import bisect
import itertools
import random

def main():
	(h, l) = map(int, input().split())
	a_add_b = l ** 2 / h
	a_sub_b = h
	b = (a_add_b - a_sub_b) / 2
	print('%.10f' % b)
main()


h = 0
l = 0
(h, l) = map(int, input().split())
x = (pow(l, 2) - pow(h, 2)) / (2 * h)
print(x)


(h, l) = map(int, input().split())
num = l ** 2 - h ** 2
den = 2 * h
print(num / den)


(H, L) = map(int, input().split())
print('{:.8f}'.format((L ** 2 + H ** 2) / (2 * H) - H))


d = list(map(int, input().split()))
ans = (d[1] ** 2 - d[0] ** 2) / (2 * d[0])
print(ans)


(h, l) = [int(w) for w in input().split()]
print((l * l - h * h) / (2 * h))


(h, l) = map(int, input().split())
print('{:.25f}'.format((l * l - h * h) / 2 / h))


(h, l) = map(float, input().split(' '))
len = float((l * l + h * h) / (2 * h))
len = len - float(h)
print('%.13f' % len)


from sys import stdin
input = []
for i in stdin:
	input.append([float(j) for j in i.split()])
h = input[0][0]
l = input[0][1]
print((l ** 2 - h ** 2) / (2 * h))


def main():
	(H, L) = map(int, input().split())
	ans = (H * H + L * L) / (2 * H) - H
	print(ans)
main()


numbs = input().split(' ')
H = int(numbs[0])
L = int(numbs[1])
up = H ** 2 + L ** 2
down = 2 * H
res = up / down
print(res - H)


from sys import *
from math import *
(n, k) = map(float, stdin.readline().split())
ans = (k ** 2 - n ** 2) / (2 * n)
print(ans)


s = list(map(int, input().rstrip().split()))
H = float(s[0])
L = float(s[1])
print((L * L - H * H) / (2 * H))


(h, l) = input().split()
h = float(h)
l = float(l)
d = (l ** 2 - h ** 2) / (2 * h)
print(d)


(h, l) = list(map(int, input().strip().split()))
print((l * l - h * h) / (2 * h))


(H, L) = map(int, input().split())
depth = (L * L - H * H) / (2 * H)
print(depth)


(h, l) = [int(x) for x in input().split()]
result = (l ** 2 - h ** 2) / (h * 2)
print('%.13f' % result)


(H, L) = [int(i) for i in input().strip().split(' ')]
ans = (H ** 2 + L ** 2) / (2 * H)
print(ans - H)


n = input().split()
H = int(n[0])
L = int(n[1])
print((L * L - H * H) / H * 0.5)


inp = list(map(int, input().split()))
h = inp[0]
l = inp[1]
print((l * l - h * h) / (2 * h))


(h, l) = map(int, input().split())
fn = (l ** 2 + h ** 2) / (2 * h)
print('{0:.15f}'.format(fn - h))


(l, h) = list(map(int, input().split()))
(l, h) = (max(l, h), min(l, h))
print((l ** 2 - h ** 2) / (2 * h))


from math import *
(h, l) = map(int, input().split())
(k, m) = (sqrt(h ** 2 + l ** 2) / 2, atan2(l, h))
print(1 / cos(m) * k - h)


import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)

def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
import math
from bisect import bisect_left
(a, b) = getList()
ans = (b ** 2 - a ** 2) / (2 * a)
print(ans)


import math
array = input()
array = [int(x) for x in array.split()]
(H, L) = (array[0], array[1])
x = (L ** 2 - H ** 2) / (2 * H)
print(x)


(a, b) = list(map(int, input().rstrip().split()))
x = b ** 2 - a ** 2
x = x / (2 * a)
print(x)


(h, l) = [int(x) for x in input().split()]
k = (l ** 2 - h ** 2) / (2 * h)
print('%.13f' % k)


fst = list(map(float, input().split()))
print((pow(fst[0], 2) + pow(fst[1], 2)) / (2 * fst[0]) - fst[0])


import sys
from collections import defaultdict as dd
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
(h, l) = ri()
one = (l * l - h * h) / (2 * h)
print(one)


nums = input().split()
(H, L) = (int(nums[0]), int(nums[1]))
out = float(L ** 2 - H ** 2) / float(2 * H)
print(out)


import math
import os
import random
import re
import sys

def find_depth(h, l):
	divisor = 2 * h
	dividend = l ** 2 - h ** 2
	print(dividend / divisor)
hl = input().split()
h = int(hl[0])
l = int(hl[1])
find_depth(h, l)


q = list(map(int, input().split()))
print((q[1] ** 2 - q[0] ** 2) / (2 * q[0]))


(h, l) = map(int, input().split())
r = l * l - h * h
r = r / (2 * h)
print('%.13f' % r)


while True:
	try:
		(h, l) = map(float, input().split())
		print((l ** 2 - h ** 2) / (2 * h))
	except EOFError:
		break


(h1, l1) = input().split()
h = int(h1)
l = int(l1)
x = (l * l - h * h) / (2 * h)
print(x)


def main():
	pass
main()
(L, H) = map(int, input().split())
a = H ** 2 - L ** 2
print(a / (L / 2) / 2 / 2)


alph = 'abcdefghijklmnopqrstuvwxyz'
(h, l) = map(int, input().split())
k = (l * l - h * h) / 2 / h
print('%.10f' % k)


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def main():
	(h, l) = map(int, input().split())
	print('{:.13f}'.format((l * l - h * h) / (2 * h)))
main()


import math

def f():
	(H, L) = [int(x) for x in input().split()]
	a = math.sqrt(H ** 2 + L ** 2)
	sin_alfa = L / a
	cos_alfa = H / a
	temp_x = a * sin_alfa / (2 * sin_alfa * cos_alfa)
	x = temp_x - H
	print(x)
f()


h = input()
h = h.split(' ')
l = int(h[1])
h = int(h[0])
A = (l ** 2 - h ** 2) / (2 * h)
print(A)


(a, b) = map(int, input().split())
deno = 2 * a
b = b ** 2
a = a ** 2
diff = b - a
ans = diff / deno
print('%.13f' % ans)


(h, l) = map(int, input().split())
a = abs(h * h - l * l)
b = 2 * h
print('%.8f' % (a / b))


t = input().strip().split(' ')
assert len(t) == 2
t = [int(e) for e in t]
(H, L) = t
x = (L * L - H * H) / 2.0 / H
print(x)


import math
(h, l) = map(float, input().split())
hyp = math.sqrt(h * h + l * l)
alpha = math.atan(l / h)
x = hyp / math.sin(2 * alpha) * math.sin(alpha)
print(x - h)


import math
(h, l) = map(int, input().split())
b = math.sqrt(h ** 2 + l ** 2)
a = math.atan(l / h)
a = b / (2 * math.cos(a))
print(a - h)


i = input().split()
i[0] = int(i[0])
i[1] = int(i[1])
print((i[0] * i[0] + i[1] * i[1]) / (2 * i[0]) - i[0])


import sys, os, io
input = sys.stdin.readline
PI = 3.141592653589793
INF = float('inf')
MOD = 1000000007

def bin32(num):
	return '{0:032b}'.format(num)

def add(x, y):
	return (x + y) % MOD

def sub(x, y):
	return (x - y + MOD) % MOD

def mul(x, y):
	return x * y % MOD

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

def lcm(x, y):
	return x * y // gcd(x, y)

def power(x, y):
	res = 1
	x %= MOD
	while y != 0:
		if y & 1:
			res = mul(res, x)
		y >>= 1
		x = mul(x, x)
	return res

def mod_inv(n):
	return power(n, MOD - 2)

def prob(p, q):
	return mul(p, power(q, MOD - 2))

def ii():
	return int(input())

def li():
	return [int(i) for i in input().split()]

def ls():
	return [i for i in input().split()]
(h, l) = li()
ans = (l ** 2 - h ** 2) / (2 * h)
print(ans)


(x, y) = [int(a) for a in input().split()]
d = y ** 2 - x ** 2
d = d / (2 * x)
print(d)


import sys
import re
import random
import math
import os
i = list(map(int, input().rstrip().split()))
print(round((i[1] ** 2 - i[0] ** 2) / (2 * i[0]), 13))


(H, L) = map(int, input().split())
s = (L ** 2 + H ** 2) / (2 * H)
print(s - H)


(h, l) = map(int, input().split())
ans = round((l ** 2 - h ** 2) / 2 / h, 6)
print('{:.8f}'.format((l ** 2 - h ** 2) / 2 / h))


from sys import stdin
input = lambda : stdin.readline().strip()
(a, b) = list(map(int, input().split()))
print((b ** 2 - a ** 2) / (2 * a))


l = list(map(int, input().split()))
print((l[1] ** 2 - l[0] ** 2) / (2 * l[0]))


(x, y) = map(int, input().split(' '))
z = (y ** 2 - x ** 2) / (2 * x)
print(z)


import os
import sys
import bisect
from math import gcd, ceil
from heapq import heapify, heappop, heappush
from io import BytesIO, IOBase

def main():
	(h, l) = map(int, input().split())
	x = h ** 2 - l ** 2
	print(abs(x / (2 * h)))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = lambda s: self.buffer.write(s.encode()) if self.writable else None

	def read(self):
		if self.buffer.tell():
			return self.buffer.read().decode('ascii')
		return os.read(self._fd, os.fstat(self._fd).st_size).decode('ascii')

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline().decode('ascii')

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

def print(*args, sep=' ', end='\n', file=sys.stdout, flush=False):
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(end)
	if flush:
		file.flush()
(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.setrecursionlimit(10000)
main()


a = input().split()
b = int(a[0])
c = int(a[1])
print((c ** 2 - b ** 2) / (2 * b))


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
(H, L) = map(int, input().split())
ans = (L * L - H * H) / (2 * H)
print(ans)


lokda = input().split(' ')
h = int(lokda[0])
l = int(lokda[1])
r = (l ** 2 - h ** 2) / (2 * h)
print(r)


(h, l) = map(int, input().split())
sum = (l * l - h * h) / (2.0 * h)
print('%.12f' % sum)


a = [int(i) for i in input().split(' ')]
h = float(a[0])
l = float(a[1])
y = (l * l / h + h) / 2 - h
print(y)


import math
x = [int(i) for i in input().split()]
H = x[0]
L = x[1]
if 1 < H < L < 10 ** 6:
	pass
print((L * L - H * H) / (2 * H))


from sys import stdin
input = stdin.readline
from decimal import Decimal
(h, l) = list(map(Decimal, input().split()))
print((l ** 2 - h ** 2) / (2 * h))


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd, log10, atan, tan

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

def get_ints():
	return map(float, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(h, l) = get_ints()
alpha = atan(l / h)
alpha2 = atan(h / l)
beta = alpha - alpha2
ans = l * tan(beta)
print(ans)


import math
(h, l) = map(int, input().split())
ans = l * math.tan(math.atan(l / h) - math.atan(h / l))
print(ans)


import math

def main():
	arr = list(map(int, input().split(' ')))
	H = arr[0]
	L = arr[1]
	G = (L ** 2 - H ** 2) / (2 * H)
	print(G)
main()


(H, L) = input().split()
H = float(H)
L = float(L)
A = (H ** 2 + L ** 2) / (2 * H)
print(A - H)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(h, l) = I()
print((l ** 2 - h ** 2) / (2 * h))


(a, b) = input().split()
h = int(a)
l = int(b)
out = (l * l - h * h) / (2 * h)
print(out)


hl = [int(i) for i in input().split()]
h = hl[0]
l = hl[1]
print((l ** 2 - h ** 2) / (2 * h))


(a, b) = map(int, input().split())
c = a * a - b * b
c /= -2 * a
print(c)


(h, l) = [int(s) for s in input().split()]
print((l ** 2 - h ** 2) / (2 * h))


c = list(map(int, input().split()))
h = c[0]
l = c[1]
ans = (l ** 2 - h ** 2) / (2.0 * h)
print(ans)


(H, L) = map(int, input().split())
print('%.13f' % (1.0 * (L * L - H * H) / (2 * H)))


(n, m) = map(int, input().split())
print(abs(n ** 2 - m ** 2) / (2 * n))


t = list(map(eval, input().split()))
h = t[0]
l = t[1]
ans = (l * l - h * h) / 2.0
ans = ans / h
print(ans)


(h, l) = map(int, input().split())
depth = (l ** 2 - h ** 2) / (2 * h)
print(str.format('{0:.13f}', depth))


[h, l] = [int(v) for v in input().split(' ')]
print((l ** 2 - h ** 2) / (2 * h))


n = input()
a = [int(i) for i in n.split()]
ans = (a[1] * a[1] - a[0] * a[0]) / (2 * a[0])
print('{:.13f}'.format(ans))


inputs = input().split(' ')
h = int(inputs[0])
l = int(inputs[1])
y = l ** 2 - h ** 2
x = 2 * h
ans = y / x
print(ans)


(h, l) = input().split()
h = int(h)
l = int(l)
ans = (l * l - h * h) / (2 * h)
print(round(ans, 8))


(h, l) = map(int, input().split())
print(round((l ** 2 - h ** 2) / (2 * h), 10))


(h, l) = map(int, input().split(' '))
out = float(h ** 2 + l ** 2) / (2 * h) - h
print(out)


import math
gi = lambda : list(map(float, input().strip().split()))
(h, l) = gi()
ang = 90 - math.atan(h / l)
ang = 180 - 2 * ang
ang /= 2
d = math.sqrt(h * h + l * l) / 2
ans = d / math.sin(ang) - h
print(ans)


import sys
(h, l) = [float(x) for x in sys.stdin.readline().strip().split()]
print((l * l - h * h) / (2.0 * h))


(h, l) = map(int, input().split())
ans = float((l ** 2 - h ** 2) / (2 * h))
print(ans)


list = []
list = input().split()
h = float(list[0])
l = float(list[1])
print((pow(h, 2) + pow(l, 2)) / (2 * h) - h)


(h, l) = input(' ').split()
h = float(h)
l = float(l)
y = float(l ** 2 - h ** 2)
z = float(y / (2 * h))
print('%.15f' % z)


HL = list(map(float, input().split(' ')))
print((HL[1] ** 2 - HL[0] ** 2) / (2 * HL[0]))


(h, l) = map(int, input().split())
print('{:.9f}'.format((l ** 2 - h ** 2) / (2 * h)))


import math
(h, l) = (int(x) for x in input().split(' '))
ans = (l * l - h * h) / (2 * h)
print('%.15f' % ans)


(h, l) = [int(i) for i in input().split()]
result = (-h * h + l * l) / (2 * h)
print('{:.6f}'.format(result))


(h, l) = list((int(i) for i in input().split()))
x = (l ** 2 - h ** 2) / (2 * h)
print(x)


(L, H) = list(map(float, input().split()))
res = (L ** 2 + H ** 2) / (2 * L) - L
print(res)
exit(0)


import sys

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

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

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math
from collections import defaultdict
(h, l) = ria()
x = pow(l, 2) - pow(h, 2)
x = x / (2 * h)
print('%.13f' % x)


(h, l) = map(int, input().split())
ans = (pow(l, 2) - pow(h, 2)) / (2 * h)
print('%.6f' % ans)


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
(h, l) = map(int, input().split())
print((l ** 2 - h ** 2) / (2 * h))


import bisect, math

def foo(h, l):
	return (l ** 2 - h ** 2) / (2 * h)
for _ in range(1):
	(x, y) = map(int, input().split())
	print(foo(x, y))


from sys import stdin
inp = lambda : stdin.readline().strip()
(h, l) = [int(x) for x in inp().split()]
print((l ** 2 - h ** 2) / (2 * h))


l1 = [int(x) for x in input().split()]
(h, l) = (l1[0], l1[1])
d = (l ** 2 - h ** 2) / 2 / h
print(d)


def main():
	(h, l) = [int(v) for v in input().split()]
	print((l * l - h * h) / (2 * h))
main()


(H, L) = map(int, input().split())
if H <= 1e-06:
	print('0')
else:
	print((L * L - H * H) / (2 * H))


list = list(map(float, input().split()))
h = list[0]
l = list[1]
print((l * l - h * h) / 2 / h)


(h, l) = map(int, input().split())
a = l ** 2 - h ** 2
e = a / (2 * h)
print(e)


(x, y) = input().split()
(x, y) = [int(x), int(y)]
output = y ** 2 - x ** 2
r = 2 * x
print(output / r)


s = input()
(H, L) = s.split(' ')
H = int(H)
L = int(L)
A = (L * L - H * H) / (2.0 * H)
print(A)


(h, l) = map(int, input().split())
newh = h * h
newl = l * l
num = (newl - newh) / 2
ans = num / h
print(round(ans, 13))


(h, l) = map(int, input().split())
d = (l * l - h * h) / (2 * h)
print(format(d, '.13f'))


lisnum = input()
lisnum = lisnum.split(' ')
H = float(lisnum[0])
L = float(lisnum[1])
A = (L ** 2 - H ** 2) / (2 * H)
print(float(A))


(H, L) = [int(s) for s in input().split()]
print((L ** 2 + H ** 2) / (2 * H) - H)


a = list((int(x) for x in input().split()))
h = a[0]
l = a[1]
print(format((l ** 2 - h ** 2) / (2 * h), '.13f'))


k = [float(i) for i in input().split()]
h = k[0]
l = k[1]
p = 2 * h
print('{:.13f}'.format((l ** 2 - h ** 2) / p))


import math
from decimal import *
(h, l) = input().split(' ')
(h, l) = (int(h), int(l))
PI = 3.141592653589793
depth = (l * l - h * h) / (2 * h)
print(depth)


from sys import stdin
(h, l) = map(int, stdin.readline().split())
ans = (l * l - h * h) / (2 * h)
print(round(ans, 13))


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
(h, l) = map(int, input().split())
print((l * l - h * h) / 2 / h)


import sys
(n, x) = input().split()
(n, x) = [int(n), int(x)]
ans = (x ** 2 - n ** 2) / (2 * n)
print(ans)


(h, l) = [int(j) for j in input().split()]
print((l ** 2 - h ** 2) / (2 * h))


(h, l) = map(int, input().split())
x = (l * l - h * h) / (2 * h)
print('{0:.8f}'.format(x))


(h, l) = map(int, input().split())
s = abs(l * l - h * h)
print(s / (h * 2))


(h, l) = list(map(int, input().split()))
r = (l ** 2 - h ** 2) / (2 * h)
print(r)


(x, y) = input().split()
a = int(x)
b = int(y)
t = (b * b - a * a) / (2 * a)
print(t)