Harry Potter and He-Who-Must-Not-Be-Named engaged in a fight to the death once again. This time they are located at opposite ends of the corridor of length l. Two opponents simultaneously charge a deadly spell in the enemy. We know that the impulse of Harry's magic spell flies at a speed of p meters per second, and the impulse of You-Know-Who's magic spell flies at a speed of q meters per second.

The impulses are moving through the corridor toward each other, and at the time of the collision they turn round and fly back to those who cast them without changing their original speeds. Then, as soon as the impulse gets back to it's caster, the wizard reflects it and sends again towards the enemy, without changing the original speed of the impulse.

Since Harry has perfectly mastered the basics of magic, he knows that after the second collision both impulses will disappear, and a powerful explosion will occur exactly in the place of their collision. However, the young wizard isn't good at math, so he asks you to calculate the distance from his position to the place of the second meeting of the spell impulses, provided that the opponents do not change positions during the whole fight.


-----Input-----

The first line of the input contains a single integer l (1 ≤ l ≤ 1 000) — the length of the corridor where the fight takes place.

The second line contains integer p, the third line contains integer q (1 ≤ p, q ≤ 500) — the speeds of magical impulses for Harry Potter and He-Who-Must-Not-Be-Named, respectively.


-----Output-----

Print a single real number — the distance from the end of the corridor, where Harry is located, to the place of the second meeting of the spell impulses. Your answer will be considered correct if its absolute or relative error will not exceed 10^{ - 4}. 

Namely: let's assume that your answer equals a, and the answer of the jury is b. The checker program will consider your answer correct if $\frac{|a - b|}{\operatorname{max}(1, b)} \leq 10^{-4}$.


-----Examples-----
Input
100
50
50

Output
50

Input
199
60
40

Output
119.4



-----Note-----

In the first sample the speeds of the impulses are equal, so both of their meetings occur exactly in the middle of the corridor.

Difficulty: EASY
Tags: Mathematics

Implementation

Starter code:

Solutions:
l = int(input().strip())
p = int(input().strip())
q = int(input().strip())
ans = l * p / (p + q)
print(ans)


d = int(input())
h = int(input())
v = int(input())
print(h * d / (h + v))


l = int(input())
p = int(input())
q = int(input())
r = q * l / (p + q)
print(l - r)


(l, p, q) = map(int, [input(), input(), input()])
print(l * p / float(p + q))


l = int(input())
Hs = int(input())
VMs = int(input())
spdRap = Hs + VMs
firstHit = l * Hs / spdRap
VMdistH0 = firstHit / Hs * VMs
if VMdistH0 >= l - firstHit:
	VMposH0 = VMdistH0 - (l - firstHit)
	secHit = (l - VMposH0) * Hs / spdRap
elif l / Hs <= (l - firstHit - VMdistH0) / VMs:
	secHit = (firstHit + VMdistH0) / (Hs - VMs) * Hs
else:
	posHSVM0 = (l - firstHit - VMdistH0) / VMs * Hs
	secHit = (l - posHSVM0) * Hs / spdRap + posHSVM0
print(secHit)


l = int(input())
GP = int(input())
SZK = int(input())
print(l / (GP + SZK) * GP)


l = int(input())
p = int(input())
q = int(input())
f = l * (p / (p + q))
print(f)


def main():
	(l, p, q) = (int(input()), int(input()), int(input()))
	print(l * p / (p + q))
main()


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
ans = p * t
print(ans)


(l, p, q) = [int(input()) for _ in range(3)]
ans = p * l / (p + q)
print(ans)


l = int(input())
h = int(input())
v = int(input())
print(h / (v + h) * l)


n = int(input())
p = int(input())
q = int(input())
mn = p * (n / (q + p))
print(mn)


l = int(input())
h = int(input())
w = int(input())
o = l * h / (w + h)
print(o)


a = float(input())
b = float(input())
c = a * (b / (b + float(input())))
print(c)


L = int(input())
(a, b) = (int(input()), int(input()))
print(L * a / (a + b))


(l, p, q) = [int(input()) for _ in [1, 2, 3]]
print(l * p / (p + q))


s = int(input())
p = int(input())
q = int(input())
w = 0
t1 = s / (p + q)
s1 = p * t1
t12 = s1 / p
t22 = (s - s1) / q
if t12 > t22:
	s -= (t12 - t22) * q
else:
	s -= (t22 - t12) * p
	w = (t22 - t12) * p
print(p * (s / (p + q)) + w)


n = int(input())
m = int(input())
k = int(input())
s = n * m
s1 = m + k
print(s / s1)


l = int(input())
a = int(input())
b = int(input())
print(l * a / (a + b))


import sys
from functools import reduce
from collections import Counter
import time
import datetime
from math import sqrt, gcd

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

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

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

def mips():
	return map(str, sys.stdin.readline().split())

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

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.insert(i, arr)
	return lst

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def minJumps(arr, n):
	jumps = [0 for i in range(n)]
	if n == 0 or arr[0] == 0:
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if i <= j + arr[j] and jumps[j] != float('inf'):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n - 1]

def dic(arr):
	return Counter(arr)

def check_prime(n):
	if n < 2:
		return False
	for i in range(2, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True
l = ip()
a = ip()
b = ip()
print(a * l / (a + b))


(a, b, c) = (int(input()), int(input()), int(input()))
print(a * (b / (b + c)))


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
d = p * t
print(d)


n = float(input())
q = float(input())
p = float(input())
print(n * q / (p + q))


print(int(input()) * (1 - 1 / (1 + int(input()) / int(input()))))


n = int(input())
a = int(input())
print(n * a / (a + int(input())))


def solve(l, p, q):
	first_point = p * l / (p + q)
	return first_point
l = int(input())
p = int(input())
q = int(input())
print(solve(l, p, q))


n = int(input())
m = int(input())
k = int(input())
print(n / (m + k) * m)


c = int(input())
v1 = int(input())
v2 = int(input())
print(c * v1 / (v1 + v2))


l = float(input())
a = float(input())
b = float(input())
print(l * a / (a + b))


l = int(input())
n = int(input())
m = int(input())
print(l * (n / (n + m)) + 1e-09)


from sys import stdin, stdout
input = stdin.readline
l = int(input())
p = int(input())
q = int(input())
stdout.write(str(p * q * l / q / (q + p)))


d = int(input())
h = int(input())
o = int(input())
print(d * (h / (h + o)))


l = int(input())
p = int(input())
q = int(input())
print('%.4f' % (p * l / (p + q)))


l = int(input())
p = int(input())
q = int(input())
print(l / 2 if p == q else l * (p / (p + q)))


l = int(input())
p = int(input())
q = int(input())
x = q * l / (p + q)
if int(l - x) == l - x:
	print(int(l - x))
else:
	print(l - x)


distance = int(input())
h_spell = int(input())
lw_spell = int(input())
print(h_spell * (distance / (h_spell + lw_spell)))


(l, x, y) = (int(input()), int(input()), int(input()))
print('%.7f' % (x * l / (x + y)))


l = int(input())
m = int(input())
n = int(input())
x = m * l / (m + n)
print(x)


r = lambda : int(input())
d = r()
h = r()
v = r()
print(h * d / (h + v))


l = int(input())
v1 = int(input())
v2 = int(input())
print(l * v1 / (v1 + v2))


d = int(input())
v1 = int(input())
v2 = int(input())
x = d / (v1 + v2)
print(x * v1)


d = int(input())
s1 = int(input())
s2 = int(input())
t = d / (s1 + s2)
c = t * s1
if int(c) == c:
	print(int(c))
else:
	print(c)


masofa = int(input())
skorost1 = int(input())
skorost2 = int(input())
x = masofa / (skorost1 + skorost2)
print(skorost1 * x)


s = int(input())
g = int(input())
q = int(input())
print(s * 1.0 / (g + q) * g)


x = int(input())
y = int(input())
z = int(input())
print(x / (y + z) * y)


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
pos_p = l - p * t
print(l - pos_p)


(n, p, q) = (int(input()), int(input()), int(input()))
print(n * (1 / (1 + q / p)))


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(l, p, q):
	return l * p / (p + q)

def print_stderr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def main():
	l = int(input())
	p = int(input())
	q = int(input())
	result = solve(l, p, q)
	print(result)
main()


l = int(input())
p = int(input())
q = int(input())
y = float(p * l / (p + q))
print(y)


l = int(input())
p = int(input())
q = int(input())
print(1.0 * l / (p + q) * p)


(l, p, q) = [int(input()) for i in range(3)]
print(p * (l / (p + q)))


n = int(input(''))
a = int(input(''))
b = int(input(''))
d = n / (a + b)
print(d * a)


L = int(input())
p = int(input())
q = int(input())
print(p * (L / (p + q)))


def solve(l, p, q):
	t = l / (p + q)
	return t * p
l = int(input())
p = int(input())
q = int(input())
print(solve(l, p, q))


a = []
for i in range(3):
	a.append(int(input()))
(l, p, q) = (a[0], a[1], a[2])
print(p * (l / (p + q)))


def point(l, a, b):
	return l * a / (a + b)
l = int(input())
a = int(input())
b = int(input())
print(point(l, a, b))


l = int(input())
p = int(input())
q = int(input())
dis = l * p / (p + q)
print(dis)


l = int(input())
p = int(input())
q = int(input())
s = p / (p + q)
print(l * s)


n1 = int(input())
n2 = int(input())
n3 = int(input())
n4 = n2 + n3
t = n1 / n4
print(t * n2)


x = int(input())
a = int(input())
b = int(input())
print(a * (x / (a + b)))


l = int(input())
p = int(input())
q = int(input())
res = l * (p / (p + q))
print(res)


L = int(input())
V1 = int(input())
V2 = int(input())
t = L / (V1 + V2)
S = t * V1
print(S)


from fractions import Fraction
Corridor_Length = float(input())
Harry_Speed = float(input())
You_Know_Speed = float(input())
Relative_Speed = 0.0
flag = 0
if Harry_Speed == You_Know_Speed:
	print(Corridor_Length / 2)
else:
	if Harry_Speed < You_Know_Speed:
		Relative_Speed = Harry_Speed / You_Know_Speed
	else:
		flag = 1
		Relative_Speed = You_Know_Speed / Harry_Speed
	x = str(Fraction(str(Relative_Speed)).limit_denominator(1000))
	divisor_location = x.find('/')
	first_fraction = x[:divisor_location]
	second_fraction = x[divisor_location + 1:]
	summation = int(first_fraction) + int(second_fraction)
	div = Corridor_Length / summation
	if flag == 1:
		Har_out = int(second_fraction) * div
	else:
		Har_out = int(first_fraction) * div
	print(Har_out)


d = int(input())
h = int(input())
n = int(input())
print(d - n * d / (n + h))


l = int(input())
p = 1 / int(input())
q = 1 / int(input())
x = p + q
t = l / x
print(q * t)


withFile = 0
if withFile == 1:
	fin = open('input.txt', 'r')
	fout = open('output.txt', 'w')

def getl():
	if withFile == 0:
		return input()
	else:
		return fin.readline()

def printl(s):
	if withFile == 0:
		print(s)
	else:
		fout.write(str(s))

def get_arr():
	x = getl().split(' ')
	if x[-1] == '':
		x = x[:-1]
	return list(map(int, x))
l = get_arr()[0]
b = get_arr()[0]
c = get_arr()[0]
t = l / (1.0 * b + c)
print(t * b)
if withFile == 1:
	fin.close()
	fout.close()


K = int(input())
a = int(input())
b = int(input())
print('{:.5f}'.format(a * K / (a + b)))


import sys
from sys import stdin, stdout
l = int(input())
speed1 = int(input())
speed2 = int(input())
print(float(l * speed1) / float(speed1 + speed2))


n = int(input())
a = int(input())
b = int(input())
t = n / (a + b)
print(a * t)


def main():
	(l,) = read()
	(p,) = read()
	(q,) = read()
	return p * l / (p + q)

def read(typ=int):
	input_line = input().strip()
	if typ is None:
		return input_line
	return list(map(typ, input_line.split()))

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='')
write(main())


import sys
from collections import deque
read = lambda : list(map(int, sys.stdin.readline().split()))
(l,) = read()
(p,) = read()
(q,) = read()
print(l * p / (p + q))


s = float(input())
x = float(input())
y = float(input())
print('%.4f' % float(s / (x + y) * x))


l = int(input())
p = int(input())
q = int(input())
t = l * 3 / (p + q)
s = p / q * l / (p / q + 1)
print(p * t - 2 * s)


l = int(input())
p = int(input())
q = int(input())
print(str(l * p / (p + q)))


from math import ceil, sqrt, floor
import sys
(n, x, y) = (int(input()), int(input()), int(input()))
print(x * n / (x + y))


length = int(input())
w1 = int(input())
w2 = int(input())
ratio = w1 / (w1 + w2)
print(length * ratio)


l = int(input())
vg = int(input())
vv = int(input())
tm = l / (vg + vv)
sm = tm * vg
print(sm)


(hall, p, q) = (int(input()), int(input()), int(input()))
print(hall * p / (p + q))


length = int(input())
harrys_speed = int(input())
other_speed = int(input())

def calculate_distance(l, p, q):
	t = l / (p + q)
	distance = t * p
	return distance
print(calculate_distance(length, harrys_speed, other_speed))


l = int(input())
p = int(input())
q = int(input())
time_of_meeting = l / (p + q)
distance_from_harry = time_of_meeting * p
print(distance_from_harry)


l = int(input())
q = int(input())
p = int(input())
x = q * l / (q + p)
print(x)


l = float(input())
p = float(input())
q = float(input())
total = l / (p + q) * p
print(int(total) if total // 1 == total else total)


n = int(input())
a = int(input())
b = int(input())
print(round(a / (a + b) * n, 8))


lens = int(input())
p = int(input())
q = int(input())
print(p * (lens / (p + q)))


L = int(input())
P = int(input())
Q = int(input())
ans = P * (L / (P + Q))
print(ans)


l = float(input())
p = float(input())
q = float(input())
result = l / (p + q) * p
print(result)


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
a = p * t
print(a)


__author__ = 'suvasish'
l = int(input())
p = int(input())
q = int(input())
print(round(p * (l / (p + q)), 5))


import os
from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

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

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]

def read_str_list():
	return [x for x in stdin.readline().split().split()]

def main():
	distance = read_int()
	harry = read_int()
	wmnb = read_int()
	print('{0:.4f}'.format(distance * (harry / (harry + wmnb))))
main()


(l, p, q) = (int(input()), int(input()), int(input()))
impulse_sum = p + q
a = 0
while l > 0:
	if l > impulse_sum:
		a += p
	else:
		a += p * (l / impulse_sum)
	l = l - impulse_sum
print(a)


L = int(input())
v1 = int(input())
v2 = int(input())
v = v1 + v2
t = L / v
print(v1 * t)


a = int(input())
s = int(input())
d = int(input())
z = []
z.append(s)
z.append(d)
sum1 = s + d
c = a / sum1
print(c * s)


import sys
l = int(input())
p = int(input())
q = int(input())
print('%.4f' % (p * (l / (p + q))))


l = int(input())
p = int(input())
q = int(input())
a = p * l
b = p + q
if a % b == 0:
	print(int(a / b))
else:
	print(a / b)


import sys
import math
import bisect
import itertools
import random

def main():
	l = int(input())
	p = int(input())
	q = int(input())
	ans = l * p / (p + q)
	print('%.10f' % ans)
main()


m = input()
l = int(m)
n = input()
p = int(n)
o = input()
q = int(o)
a = l / (p + q)
print(a * p)
print('\n')


l = int(input())
a = int(input())
b = int(input())
t = l / (a + b)
s = t * a
print('%0.4f' % s)


import sys
longitud = float(input())
a = float(input())
b = float(input())
resp = longitud / (1.0 + b / a)
print(resp)


3
l = int(input())
p = int(input())
q = int(input())
print(p * l / (p + q))


wl = int(input())
a = int(input())
b = int(input())
t = float(wl) / float(a + b)
print(float(t) * float(a))


l = int(input())
p = int(input())
q = int(input())
k = p / q
print(l * k / (1 + k))


l = input()
p = input()
q = input()
l = int(l)
p = int(p)
q = int(q)
here = l / (p + q)
print(p * here)


I = lambda : int(input())
l = I()
p = I()
q = I()
print(l / (p + q) * p)


inp = lambda : int(input())
(l, p, q) = (inp(), inp(), inp())
r = p * l / (p + q)
print(r)


l = int(input())
Harry = int(input())
HWO = int(input())
print(Harry * (l / (Harry + HWO)))


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
c1 = p * t
print(c1)


def f(ll):
	(l, p, q) = ll
	return l * p / (p + q)
l = [int(input()) for _ in range(3)]
print(f(l))


(len, q_speed, p_speed) = (int(input()), int(input()), int(input()))
print(len * q_speed / (q_speed + p_speed))


i = int(input())
p = int(input())
q = int(input())
print(i * p / (p + q))


l = [int(input()) for i in range(3)]
w = l[0] * (l[1] / (l[1] + l[2]))
print(w)


from sys import stdin
from sys import exit
live = True
if not live:
	stdin = open('data.in', 'r')
d = int(stdin.readline())
v1 = int(stdin.readline())
v2 = int(stdin.readline())
print(v1 * d / (v1 + v2))
if not live:
	stdin.close()


l = []
for _ in range(3):
	l.append(float(input()))
d = l[0]
print(d / (l[1] + l[2]) * l[1])


n = int(input())
p = int(input())
q = int(input())
a = n
if p + q == n:
	print(n - q)
else:
	a = a / (p + q)
	print(n - a * q)


l = int(input())
p = int(input())
q = int(input())
t1 = l / (p + q)
mp = p * t1
mq = q * t1
print(mp)


class CodeforcesTask591ASolution:

	def __init__(self):
		self.result = ''
		self.l = 0
		self.p = 0
		self.q = 0

	def read_input(self):
		self.l = int(input())
		self.p = int(input())
		self.q = int(input())

	def process_task(self):
		step = 10 ** (-6)
		a = self.p * self.l / (self.p + self.q)
		v1 = -self.p
		v2 = self.q
		p1 = a
		p2 = a
		while abs(p1 - p2) > 1e-05:
			p1 += step * v1
			p2 += step * v2
			if p1 < 0:
				v1 = -v1
			if p2 > self.l:
				v2 = -v2
		self.result = str(p1)

	def get_result(self):
		return self.result
Solution = CodeforcesTask591ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


l = int(input())
p = int(input())
q = int(input())
print('{0:.9f}'.format(l * p / (p + q)))


distance = int(input())
p_speed = int(input())
q_speed = int(input())
timeof_p = distance / p_speed
timeof_q = distance / q_speed
print(p_speed * distance / (p_speed + q_speed))


import sys
l = int(input())
p = int(input())
q = int(input())
first_t = l / (p + q)
print(p * first_t)


n = int(input())
x = int(input())
y = int(input())
print(n * x / (x + y))


l = int(input())
speedg = int(input())
speedn = int(input())
print(l / (speedg + speedn) * speedg)


def solve():
	l = int(input())
	p = int(input())
	q = int(input())
	print(l * p / (p + q))
solve()


def dist(l, p, q):
	x = p * l / (p + q)
	print(x)
a = int(input(''))
b = int(input(''))
c = int(input(''))
dist(a, b, c)


l = int(input())
x = int(input())
y = int(input())
m = l / (x + y)
print(m * x)


def solve(l, p, q):
	t = l / (p + q)
	return round(t * p, 4)

def main():
	l = int(input())
	p = int(input())
	q = int(input())
	print(solve(l, p, q))
main()


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
ans = t * p
if ans - int(ans) == 0:
	print(int(ans))
else:
	print(ans)


def battle(l, p, q):
	return l * (p / (p + q))
L = int(input())
P = int(input())
Q = int(input())
print(battle(L, P, Q))


z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
a = int(z())
b = int(z())
c = int(z())
t = a / (b + c)
print(t * b)


x = int(input())
x1 = int(input())
x2 = int(input())
t = x / (x1 + x2)
print(x - x2 * t)


length = int(input())
p = int(input())
q = int(input())
print(length / (p + q) * p)


from sys import stdin
length = int(stdin.readline())
harry = int(stdin.readline())
voldemort = int(stdin.readline())
collision = length / (harry + voldemort) * harry
print(collision)


l = int(input())
p = int(input())
q = int(input())
print(round(l * p / (p + q), 10))


l = eval(input())
p = eval(input())
q = eval(input())
d = l / (q * (1 / p + 1 / q))
print(round(d, 4))


l = int(input())
p = int(input())
q = int(input())
t = l * p
y = p + q
print(t / y)


l = int(input())
p = int(input())
q = int(input())
x = l / (p + q)
d1 = p * x
d2 = q * x
print(d1)


t = int(input())
a = int(input())
b = int(input())
x = a + b
y = a / x
z = b / x
print(y * t)


n = int(input())
p = int(input())
q = int(input())
z = n / (p + q)
v = z * p
print(v)


c = lambda : int(input())
(a, x, y) = (c(), c(), c())
print(a * x / (x + y))


n = int(input())
p = int(input())
q = int(input())
if n % (p + q) == 0:
	print(int(n * p / (p + q)))
else:
	print(n * p / (p + q))


l = [int(input()) for x in range(3)]
print(l[0] * l[1] / (l[1] + l[2]))


import sys
(l, p, q) = [int(x) for x in sys.stdin.read().split()]
print(p * l / float(p + q))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
dist = get_int()
p = get_int()
q = get_int()
print(p / (p + q) * dist)


coridor_length = int(input())
harrys_charm = int(input())
toms_charm = int(input())
print('%.4f' % (coridor_length * harrys_charm / (harrys_charm + toms_charm)))


l = int(input())
p = int(input())
q = int(input())
t = l / (p + q)
m1 = t * p
print(m1)


(l, p, q) = map(int, [input().strip() for _ in range(3)])
segment_length = l / (p + q)
print(p * segment_length)


l = int(input())
u = int(input())
v = int(input())
print(l * u / (u + v))


from decimal import *
l = int(input())
v1 = int(input())
v2 = int(input())
t = l / (v1 + v2)
c = v1 * t
print(c)


d = int(input())
a = int(input())
b = int(input())
c = a + b
if d % c == 0:
	print(a * (d // c))
else:
	x = d // c * a
	r = d % c
	a1 = r * a / c
	ans = str(x + a1)
	print(ans)


x1 = int(input())
x2 = int(input())
x3 = int(input())
print(x1 * x2 / (x2 + x3))


d = int(input())
p = int(input())
q = int(input())
s = p * (d / (p + q))
if s % 1 == 0:
	print(int(s))
else:
	print(s)


d = int(input())
p = int(input())
q = int(input())
print(d * p / (p + q))


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

def main():
	a = int1()
	b = int1()
	c = int1()
	z = a * c / (b + c)
	if z % 10 == 0:
		print(a - a * c // (b + c))
	else:
		print(a - a * c / (b + c))
main()


l = int(input())
p = int(input())
q = int(input())
s = p + q
t = l / s
l0 = t * p
print(l0)


d = int(input())
p = int(input())
q = int(input())
frac = p / (p + q)
print('%0.5f' % (d * frac))


l = int(input())
p = int(input())
q = int(input())
sumof = p + q
print(l / sumof * p)


s = int(input())
h = int(input())
e = int(input())
if h == min(h, e):
	h1 = 1
else:
	h1 = h / min(h, e)
if e == min(h, e):
	e1 = 1
else:
	e1 = e / min(h, e)
print('%f' % (h1 * (s / (h1 + e1))))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
L = int(input())
p = int(input())
q = int(input())
print(p * L / (p + q))


import math
l = int(input().strip())
p = int(input().strip())
q = int(input().strip())
r = math.ceil(l / (p + q))
pr = p * r
qr = l - q * r
s = qr + (pr - qr) * (q / (q + p))
print(s)


l = int(input())
p = int(input())
q = int(input())
t1 = 0
if p + q > 0:
	t1 = l / (p + q)
print(t1 * p)


l = int(input())
p = int(input())
q = int(input())
c = p / (p + q)
print(c * l)


a = int(input())
p = int(input())
q = int(input())
print(a / (q / p + 1))


N = int(input())
a = int(input())
b = int(input())
print(a * (N / (a + b)))


l = int(input())
p = int(input())
q = int(input())
x = p * l / (p + q)
y = 2 * p * l * (q - p) / (p + q) ** 2
if x - int(x) == 0:
	print(int(x))
else:
	print(x)


t = int(input())
h = int(input())
v = int(input())
d = h / (h + v)
r = t * d
print(r)


def solve(l, p, q):
	return p * (l / (p + q))

def main():
	l = int(input())
	p = int(input())
	q = int(input())
	print(solve(l, p, q))
main()


import re
import sys
import math
import itertools
import collections

def inputArray(TYPE=int):
	return [TYPE(x) for x in input().split()]

def solve():
	d = int(input())
	p = int(input())
	q = int(input())
	print(p * d / (p + q))
solve()


i = input
x = int(i())
v1 = int(i())
v2 = int(i())
print(v1 * x / (v1 + v2))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

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

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

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_right(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		d = I()
		h = I()
		v = I()
		print(d * h / (h + v))
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


from math import sqrt, pow, log, log2, log10, exp
from copy import deepcopy
from fractions import gcd

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

def read_int():
	return read_ints()[0]

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

def read_float():
	return read_floats()[0]

def format_list(l):
	return ' '.join(list(map(str, l)))

def one_dim_array(n, value=0):
	return [deepcopy(value) for x in range(n)]

def two_dim_array(n, m, value=0):
	return [[deepcopy(value) for x in range(m)] for x in range(n)]

def is_prime(n):
	if n == 2:
		return True
	if n % 2 == 0:
		return False
	for i in range(3, sqrt(n) + 1):
		if n % i == 0:
			return False
	return True

def max_len_sublist(l, f):
	(start, max_length, length) = (0, 0, 0)
	for i in range(1, len(l)):
		if f(l[i], l[i - 1]):
			length += 1
		else:
			if max_length < length:
				start = i - length
				max_length = length
			length = 0
	return (start, max_length)

def tf_to_yn(b):
	return 'YES' if b else 'NO'

def longest_non_descent_subsequence(s, restore_sequence=False):
	d = one_dim_array(len(s), 0)
	for i in range(len(s)):
		possible = [d[j] + 1 if s[j] <= s[i] else 1 for j in range(i)]
		d[i] = 1 if len(possible) == 0 else max(possible)
	if not restore_sequence:
		return d[-1] if len(d) != 0 else 0
l = read_int()
p = read_int()
q = read_int()
t = l / (p + q)
print(t * p)


from sys import stdin
l = int(stdin.readline())
p = int(stdin.readline())
q = int(stdin.readline())
print('%f' % (l / (p + q) * p))


import time
l = int(input())
p = int(input())
q = int(input())
start = time.time()
print(l * p / (p + q))
finish = time.time()


l = int(input())
p = int(input())
q = int(input())
w = l / (p + q)
print(p * w)


import decimal
D = decimal.Decimal
distance = int(input())
harryx = int(input())
voldyx = int(input())
print(harryx * D(distance / (harryx + voldyx)))


l = int(input())
s = int(input())
p = int(input())
x = l / (s + p)
print(x * s)


n = int(input())
m = int(input())
p = int(input())
print(m / (p + m) * n)


def solve(l, a, b):
	(x, y) = (l / a, l / b)
	print(l * y / (x + y))
l = int(input())
a = int(input())
b = int(input())
solve(l, a, b)


l = int(input())
a = int(input())
b = int(input())
tot_time = l / (a + b)
d_a = a * tot_time
d_b = b * tot_time
print(d_a)


s = int(input())
v1 = int(input())
v2 = int(input())
s1 = s * v1
s1 = s1 / (v1 + v2)
print(s1)


__author__ = 'artyom'

def main():
	l = read()
	v1 = read()
	v2 = read()
	return v1 * l / (v1 + v2)

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
write(main())


T = int(input())
p = int(input())
q = int(input())
print(T / (p + q) * p)


l = float(input())
x = float(input())
y = float(input())
print(x * l / (x + y))


l = float(input())
p = float(input())
q = float(input())
time = l / (p + q)
dist = p * time
print(dist)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	l = I()
	p = I()
	q = I()
	return '{:0.9f}'.format(l * p / (p + q))
print(main())


a = int(input())
b = int(input())
c = int(input())
print(round(a / (b + c) * b, 4))


l = int(input())
p = int(input())
q = int(input())
m = l / (p + q)
print(m * p)


def main():
	[l, p, q] = [int(input()) for _ in range(3)]
	print(p * l / (p + q))
main()


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
l = I()
p = I()
q = I()
print(l / (p + q) * p)


(l, x, y) = map(int, [input() for i in range(3)])
print(x * l / (x + y))


X = list()
for i in range(3):
	X.append(int(input()))
print(X[0] / (X[2] / X[1] + 1))


import math
l = int(input())
v1 = int(input())
v2 = int(input())
x = v1 * l / (v1 + v2)
print(x)


l = int(input())
v1 = int(input())
v2 = int(input())
t1hit = l / (v1 + v2)
t2hit = 2 * l / (v1 + v2)
S = v1 * t2hit - t1hit * v1
S2 = v2 * t2hit - t1hit * v2
print(S)


(lambda l, p, q: print(p * l / (p + q)))(*map(lambda _: int(input()), range(3)))


n = int(input())
p = int(input())
q = int(input())
t = n / (p + q)
print(p * t)


print(float(input()) / (1 + 1 / float(input()) * float(input())))