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: interview

Starter code:

Solutions:
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.00 * b + c)
print(t*b)


if(withFile == 1):
    fin.close()
    fout.close()

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


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


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



import sys


#sys.stdin = open("input.txt")
#sys.stdout = open("output.txt", "w")

l = int(input())
p = int(input())
q = int(input())

first_t = l / (p + q)
print(p * first_t) 

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

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

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


3

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

l = int(input())
p = int(input())
q = int(input())

print(p / (p + q) * l)

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2015 missingdays <missingdays@missingdays>
#
# Distributed under terms of the MIT license.

a = int(input())
b = int(input())
c = int(input())

d = b + c

print(a * b / d)


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

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


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

l = int( input() )
p = int( input() )
q = int( input() )

ans = l * p / ( p+q )
print( ans )


s = int(input())
v1 = int(input())
v2 = int(input())

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


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

l = int(input())
p = int(input())
q = int(input())

print(l * p / (p + q))


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

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

l = int(input())
p = int(input())
q = int(input())



res = l * (p/(p+q))

print(res)


#In the name of Allah

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


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



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)


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
l = int(input())
p = int(input())
q = int(input())
print("{0:.9f}".format(l * p / (p + q)))