SmallR is an archer. SmallR is taking a match of archer with Zanoes. They try to shoot in the target in turns, and SmallR shoots first. The probability of shooting the target each time is <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a7487d7e62f90136b78ae3fbf0a008396f146e13.png" style="max-width: 100.0%;max-height: 100.0%;"/> for SmallR while <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c443c7703e51f03d0eece0b96b9e84e425878209.png" style="max-width: 100.0%;max-height: 100.0%;"/> for Zanoes. The one who shoots in the target first should be the winner.

Output the probability that SmallR will win the match.
A single line contains four integers <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/488158367221f441ba94b9475c03436069df2a7e.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
import math
from sys import stdout
from math import sqrt, inf, gcd, ceil, tan, pi, sin, cos, floor, perm, comb
import queue


# -------- info --------

# https://codeforces.com/profile/Wolxy

# -------- sys --------
MOD_9 = 998244353
MOD_1 = 1000000007

def next_int():
    return int(input())

def next_ints():
    return tuple(map(int, input().split(' ')))

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

def dis(from_loc, to_loc, *, manhattan_distance = False):
    result = 0
    if not manhattan_distance:
        for i in range(min(len(from_loc), len(to_loc))):
            result += (from_loc[i] - to_loc[i]) * (from_loc[i] - to_loc[i])
    else:
        for i in range(min(len(from_loc), len(to_loc))):
            result += abs(from_loc[i] - to_loc[i])
    return result

def vector(from_loc, to_loc):
    return to_loc[0] - from_loc[0], to_loc[1] - from_loc[1]

def product_loc(from_loc, first_loc, second_loc):
    vector1 = vector(from_loc, first_loc)
    vector2 = vector(from_loc, second_loc)
    return vector1[0] * vector2[1] - vector2[0] * vector1[1]

def product_vec(vector1, vector2):
    return vector1[0] * vector2[1] - vector2[0] * vector1[1]

def dot(from_loc, first_loc, second_loc):
    vector1 = vector(from_loc, first_loc)
    vector2 = vector(from_loc, second_loc)
    return vector1[0] * vector2[0] + vector1[1] * vector2[1]

def get_line_equation(first_loc, second_loc):

    if first_loc == second_loc:
        return None

    line_vector = vector(first_loc, second_loc)
    line_gcd = gcd(line_vector[0], line_vector[1])
    line_a, line_b = line_vector[1] // line_gcd, -line_vector[0] // line_gcd
    line_c = - line_b * first_loc[1] - line_a * first_loc[0]
    if line_a < 0:
        line_a, line_b, line_c = -line_a, -line_b, -line_c
    elif line_a == 0:
        if line_b < 0:
            line_b, line_c = -line_b, -line_c
    return line_a, line_b, line_c

def get_point_loc(line_equation, *, x_loc = None, y_loc = None):

    line_a, line_b, line_c = line_equation
    if y_loc is None and line_b != 0:
        return float(x_loc), -(line_a * x_loc + line_c) / line_b
    elif x_loc is None and line_a != 0:
        return -(line_b * y_loc + line_c) / line_a, float(y_loc)
    else:
        return None


def summon_primes_val(val):
    arr = []
    for i in range(2, val + 1):
        skip = False
        for index in range(len(arr)):
            if i % arr[index] == 0:
                skip = True
                break
        if skip:
            continue
        arr.append(i)
    return arr

# -------- functions[clearable] --------


# -------- solve[clearable] --------

def solve() -> None:
    a, b, c, d = next_ints()
    print(a * d / (c * b + a * d - a * c))


# -------- main --------

T = 1
# T = int(input())
for _ in range(T):
    solve()
