Luke Skywalker got locked up in a rubbish shredder between two presses. R2D2 is already working on his rescue, but Luke needs to stay alive as long as possible. For simplicity we will assume that everything happens on a straight line, the presses are initially at coordinates 0 and L, and they move towards each other with speed v_1 and v_2, respectively. Luke has width d and is able to choose any position between the presses. Luke dies as soon as the distance between the presses is less than his width. Your task is to determine for how long Luke can stay alive.


-----Input-----

The first line of the input contains four integers d, L, v_1, v_2 (1 ≤ d, L, v_1, v_2 ≤ 10 000, d < L) — Luke's width, the initial position of the second press and the speed of the first and second presses, respectively.


-----Output-----

Print a single real value — the maximum period of time Luke can stay alive for. Your answer will be considered correct if its absolute or relative error does not exceed 10^{ - 6}. 

Namely: let's assume that your answer is 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^{-6}$.


-----Examples-----
Input
2 6 2 2

Output
1.00000000000000000000

Input
1 9 1 2

Output
2.66666666666666650000



-----Note-----

In the first sample Luke should stay exactly in the middle of the segment, that is at coordinates [2;4], as the presses move with the same speed.

In the second sample he needs to occupy the position $[ 2 \frac{2}{3} ; 3 \frac{2}{3} ]$. In this case both presses move to his edges at the same time.

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
(x, y, z, t) = map(int, input().split())
print(y / (z + t) - x / (z + t))


(d, l, v1, v2) = map(int, input().split())
print((l - d) / (v1 + v2))


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


text = input()
(larg, p2, v1, v2) = text.split()
dist = int(p2) - int(larg)
vt = int(v1) + int(v2)
res = dist / vt
print('%.20f' % res)


(d, l, v1, v2) = [int(x) for x in input().split()]
print((l - d) / (v1 + v2))


(d, L, v1, v2) = map(int, input().split())
l = 0
r = 100000000000000000
e = 1e-10
while r - l > e:
	c = (r + l) / 2
	if v1 * c >= L - v2 * c:
		r = c
	elif L - v2 * c - v1 * c <= d:
		r = c
	else:
		l = c
print(l)


(d, L, v1, v2) = [int(word) for word in input().split()]
r = (L - d) / (v1 + v2)
print(r)


ent = input()
(d, l, v1, v2) = ent.split()
print((float(l) - float(d)) / (float(v1) + float(v2)))


(d, L, v1, v2) = list(map(int, input().split()))
t = v1 * (L - d) / (v1 * (v2 + v1))
print(t)


(a, b, c, d) = map(int, input().split())
print((b - a) / (c + d))


(d, L, v1, v2) = input().split(' ')
print((float(L) - float(d)) / (float(v1) + float(v2)))


(d, L, v1, v2) = [int(s) for s in input().split(' ')]
ans = (L - d) / (v1 + v2)
print(ans)


x = input().split()
for i in range(len(x)):
	x[i] = int(x[i])
l = (x[1] - x[0]) / (x[2] + x[3])
print(l)


string = input()
numbers = list(map(int, string.split()))
a = numbers[0]
b = numbers[1]
v1 = numbers[2]
v2 = numbers[3]
print((b - a) / (v1 + v2))


import re, sys, string, operator, functools, fractions, collections
sys.setrecursionlimit(10 ** 7)
dX = [-1, 1, 0, 0, -1, 1, -1, 1]
dY = [0, 0, -1, 1, 1, -1, -1, 1]
RI = lambda x=' ': list(map(int, input().split(x)))
RS = lambda x=' ': input().rstrip().split(x)
mod = int(1000000000.0 + 7)
eps = 1e-06
(d, L, v1, v2) = RI()
print('%.10f' % ((L - d) / (v1 + v2)))


(d, L, v1, v2) = map(float, input().split())
ret = (L - d) / (v1 + v2)
if ret < 0:
	print(0)
else:
	print(ret)


inp = list(map(int, input().split()))
d = inp[0]
l = inp[1]
v1 = inp[2]
v2 = inp[3]
if l < d:
	print(0.0)
else:
	print((l - d) / (v1 + v2))


(d, L, v1, v2) = map(int, input().split())
print((L - d) / (v1 + v2))


(d, l, v1, v2) = [int(i) for i in input().split()]
time = (l - d) / (v1 + v2)
print(time)


(d, L, v1, v2) = map(float, input().split())
time = (L - d) / (v1 + v2)
print(float(time))


def main(args):
	entrada = list(map(int, input().split()))
	d = entrada[0]
	L = entrada[1]
	v1 = entrada[2]
	v2 = entrada[3]
	totalv = v1 + v2
	s = L - d
	result = (0.0 + s) / totalv
	print(result)
	return 0
import sys
sys.exit(main(sys.argv))


(d, l, v1, v2) = [int(s) for s in input().split()]
print((l - d) / (v1 + v2))


import math
(d, l, v1, v2) = map(int, input().split(' '))
ans = (l - d) * 1.0 / (v1 * 1.0 + v2)
print('%.20f' % abs(ans))


def save(a, b, c, d):
	return '{0:.20f}'.format((b - a) / (c + d))
(D, L, v1, v2) = [int(i) for i in input().split()]
print(save(D, L, v1, v2))


(d, l, v, u) = map(int, input().split())
print((l - d) / (v + u))


(d, L, v1, v2) = [int(x) for x in input().split()]
print((L - d) / (v1 + v2))


(d, l, v1, v2) = map(int, input().split())
k = (l - d) / (v1 + v2)
print('%.9f' % max(0, k))


import math
from fractions import Fraction as frac

def solve(case_no):
	(a, b, c, d) = map(int, input().split())
	print((b - a) / (c + d))
t = 1
for i in range(1, t + 1):
	solve(i)


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
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 I():
	return int(sys.stdin.readline())

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

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

def S():
	return input()

def main():
	(d, L, v1, v2) = LI()
	v = v1 + v2
	x = L - d
	return x / v
print(main())


class CodeforcesTask624ASolution:

	def __init__(self):
		self.result = ''
		self.d_l_v_v = []

	def read_input(self):
		self.d_l_v_v = [int(x) for x in input().split(' ')]

	def process_task(self):
		time = (self.d_l_v_v[1] - self.d_l_v_v[0]) / (self.d_l_v_v[2] + self.d_l_v_v[3])
		self.result = str(time)

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


(d, L, v1, v2) = [int(x) for x in input().split()]
a = (L - d) / (v1 + v2)
print(format(a, '.6f'))


(d, l, v1, v2) = [int(i) for i in input().split()]
print(str((l - d) / (v1 + v2)))


string = input('')
vals = string.split()
ans = float((float(vals[1]) - float(vals[0])) / (float(vals[2]) + float(vals[3])))
print(ans)


def main():
	(d, l, a, b) = map(int, input().split())
	l -= d
	ans = l / (a + b)
	print(ans)
main()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
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 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 main():
	(d, l, v, u) = LI()
	s = l - d
	t = v + u
	return '{:0.9f}'.format(s / t)
print(main())


(lyckWidth, pressPosition, downVel, highVel) = map(int, input().split())
print((pressPosition - lyckWidth) / (highVel + downVel))


(d, l, v1, v2) = map(int, input().split())
print(f'{(l - d) / (v1 + v2):.20f}')


s = input().split()
d = int(s[0])
L = int(s[1])
v1 = int(s[2])
v2 = int(s[3])
c = (L * v1 - d * v1) / (v1 + v2)
answer = c / v1
print('%0.6f' % answer)


(L, p2, v1, v2) = map(int, input().split())
distance = p2 - L
velocity = v1 + v2
print('{0:.15f}'.format(distance / velocity))


(d, l, v1, v2) = map(int, input().split())
x = (l - d) / (v1 + v2)
print('%.20f' % x)


def solve():
	(d, l, v1, v2) = list(map(int, input().split()))
	print('%.12f' % ((l - d) / (v1 + v2)))
solve()


(d, L, v1, v2) = [int(x) for x in input().split()]
L = abs(L)
res = (L - d) / (v1 + v2)
print(res)


(d, L, v1, v2) = [int(i) for i in input().split(' ')]
print((L - d) / (v1 + v2))


(d, l, a, b) = map(int, input().split())
print((l - d) / (a + b))


(d, l, v1, v2) = list(map(int, input().split()))
print((l - d) / float(v1 + v2))


string = input()
(d, l, v1, v2) = string.split()
d = int(d)
l = int(l)
v1 = int(v1)
v2 = int(v2)
print(format((l - d) / (v1 + v2), '.8f'))


(a, b, c, d) = map(int, input().split())
x = b - a
y = c + d
print(x / y)


(d, l, v1, v2) = map(int, input().split())
l -= d
if l <= 0:
	print(0.0)
else:
	print(l / (v1 + v2))


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

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

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	(d, l, v1, v2) = map(int, input().split())
	print('{:.20f}'.format((l - d) / (v1 + v2)))
for _ in range(1):
	solve()


(d, l, v1, v2) = list(map(int, input().split()))
p = v1 + v2
k = v1 * (l - d) / p
print(round(k / v1, 6))


(d, L, v1, v2) = [float(t) for t in input().split()]
print((L - d) / (v1 + v2))


x = input()
x = x.split()
d = int(x[0])
L = int(x[1])
v1 = int(x[2])
v2 = int(x[3])
ans = (L - d) / (v1 + v2)
print(ans)


(d, l, v, u) = tuple(map(int, input().split()))
print('%0.9f' % ((l - d) / (u + v)))


(a, b, c, d) = map(int, input().split())
e = (b - a) / (c + d)
print('{:0.16f}'.format(e), end='')
[print(0, end='') for x in range(4)]


from math import *
arr = [int(i) for i in input().split()]
res = (arr[1] - arr[0]) / (arr[2] + arr[3])
print('%.12f' % res)


TN = 1

def solution():
	(d, L, v1, v2) = map(int, input().split())
	print((L - d) / (v1 + v2))
while TN != 0:
	solution()
	TN -= 1


(d, l, v1, v2) = map(int, input().split())
x = v1 * (l - d) / (v1 + v2)
res = x / v1
print('%.6f' % res)


dlv = input().rstrip().split()
l = int(dlv[0])
p2 = int(dlv[1])
v1 = int(dlv[2])
v2 = int(dlv[3])
dist = p2 - l
vel = v1 + v2
time = float(dist / vel)
print('%.15f ' % time)


(d, l, v1, v2) = [int(x) for x in input().split()]
print(max(0, (l - d) / (v1 + v2)))


(d, l, vr, vl) = map(int, input().split())
t = (l - d) / (vr + vl)
print(t)


from sys import stdin, stdout
import math

def calculate(d, R, L, vR, vL):
	safe = R + L - d
	speed = vR + vL
	a = float(safe / speed)
	return round(a, 6)
(d, L, v1, v2) = [int(x) for x in stdin.readline().rstrip().split()]
R = 0
ans = calculate(d, R, L, v1, v2)
stdout.write(str(ans) + '\n')


(d, L, s1, s2) = map(int, input().strip().split())
ans = (L - d) / (s1 + s2)
print(ans)


R = lambda : map(int, input().split())
(d, L, v1, v2) = R()
print((L - d) / (v2 + v1))


(d, l, v1, v2) = map(int, input().split())
x = (l - d) / (v1 + v2)
y = '{:0.12f}'.format(x)
print(y)


(d, L, v1, v2) = map(int, input().split())
ans = (L - d) / (v1 + v2)
print('{0:.10}'.format(ans))


def solve(d, L, v1, v2):
	return v1 * (L - d) / (v1 + v2) / v1

def main():
	(d, L, v1, v2) = list(map(int, input().split()))
	print(solve(d, L, v1, v2))
main()


a = input('').split(' ')
d = int(a[0])
L = int(a[1])
v1 = int(a[2])
v2 = int(a[3])
v = v1 + v2
L = L - d
t = L / v
print(t)


from math import *
(d, l, v1, v2) = map(int, input().split())
print(max(0, (l - d) / (v1 + v2)))


def main():
	[d, L, v1, v2] = [int(_) for _ in input().split()]
	print((L - d) / (v1 + v2))
main()


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


input_constants = [int(x) for x in input().split(' ')]
free_space = input_constants[1] - input_constants[0]
time = free_space / (input_constants[2] + input_constants[3])
print(time)


def press(d, L, v1, v2):
	return (L - d) / (v1 + v2)
(d, L, v1, v2) = list(map(int, input().split()))
print(press(d, L, v1, v2))


a = list(map(int, input().split()))
b = a[1] - a[0]
c = a[2] + a[3]
print(b / c)


from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *

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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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:
			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')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

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

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

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

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

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
(d, l, v1, v2) = zzz()
l -= d
print(l / (v1 + v2))


(d, L, v1, v2) = tuple(map(int, input().split()))
print(str((L - d) / (v1 + v2)))


(w, p2, v1, v2) = map(int, input().split())
p1 = 0
p2 -= w
print(p2 / (v1 + v2))


(a, b, c, d) = [int(x) for x in input().split()]
print((b - a) / (c + d))


words = input().split()
d = float(words[0])
l = float(words[1])
v1 = float(words[2])
v2 = float(words[3])
print((l - d) / (v1 + v2))


m = list(map(int, input().split()))[:4]
if m[0] < m[1]:
	h = (m[1] - m[0]) / (m[3] + m[2])
else:
	h = 0
print(h)


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


(d, L, v1, v2) = map(int, input().split())
print(f'{(L - d) / (v1 + v2):.8f}')


def main():
	(d, l, v1, v2) = map(int, input().split())
	result = float((l - d) / (v1 + v2))
	print(result)
main()


import sys

def main():
	(d, L, v1, v2) = [float(s) for s in sys.stdin.readline().split()]
	print('{:.6f}'.format((L - d) / (v1 + v2)))
main()


n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
k = int(n[3])
print(float((b - a) / (c + k)))


f = lambda : map(int, input().split())
(d, l, v1, v2) = f()
print((l - d) / (v1 + v2))


(d, L, v1, v2) = map(int, input().split())
a = round((L - d) / (v1 + v2), 15)
print(a)


(d, l, v1, v2) = list(map(int, input().split()))
i = (l - d) / (v1 + v2)
print('%.20f' % i)


[D, L, V_1, V_2] = [int(x) for x in input().split()]
print((L - D) / (V_1 + V_2))


(d, l, v1, v2) = [int(i) for i in input().split()]
vsbl = v1 + v2
s = l - d
print(s / vsbl)


(d, l, v1, v2) = map(int, input().split())
left = 0
right = l
while right - left > 1e-09:
	mi = (left + right) / 2
	if v1 * mi + v2 * mi > l - d:
		right = mi
	else:
		left = mi
print(right)


(d, l, v, c) = map(int, input().split())
print((l - d) / (v + c))


(d, p, a, b) = map(int, input().split())
print((p - d) / (a + b))


__author__ = 'Admin'
(d, L, v1, v2) = map(int, input().split())
ans = (L - d) / (v1 + v2)
print(ans)


(D, L, V1, V2) = [int(c) for c in input().split()]
print((L - D) / (V1 + V2))


INPUT = input().split(' ')
d = int(INPUT[0])
L = int(INPUT[1])
v1 = int(INPUT[2])
v2 = int(INPUT[3])
result = (L - d) / (v1 + v2)
print(result)


(d, l, x, y) = map(int, input().split())
print((l - d) / (x + y))


(d, l, u, v) = input().split()
d = int(d)
l = int(l)
u = int(u)
v = int(v)
t = float((l - d) / (v + u))
print('{0:.20f}'.format(t))


a = [float(i) for i in input().split()]
print((a[1] - a[0]) / (a[2] + a[3]))


(d, k2, v1, v2) = [int(x) for x in input().split()]
print((k2 - d) / (v1 + v2))


__author__ = 'suvasish'
(d, l, v1, v2) = map(int, input().split())
seconds = (l - d) / (v1 + v2)
print(seconds)


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

def new_list(n):
	return [0 for i in range(n)]

def new_matrix(n, m=0):
	return [[0 for i in range(m)] for i in range(n)]
(d, l, v1, v2) = read_list()
t = l / (v1 + v2)
t -= d / (v1 + v2)
print(t)


(l, d, v1, v2) = map(int, input().split())
v = v1 + v2
a = v
x = d - l
if v - x > 19995:
	v = 2000
ans = str(x / v).split('.')
if a - x > 19995:
	ans[1] = '0' + ans[1] + '0' * (19 - len(ans[1]))
else:
	ans[1] = ans[1] + '0' * (20 - len(ans[1]))
print('.'.join(ans))


read = lambda : map(int, input().split())
(d, L, v1, v2) = read()
ans = (L - d) / (v1 + v2)
print(ans)


k = list(map(int, input().split()))
print((k[1] - k[0]) / sum(k[2:]))


(d, l, v, u) = map(int, input().split())
x = v * (l - d) / (v + u)
ans = x / v
print('%.6f' % ans)


import re
st = input()
s = re.split('[\\s]', st)
d = int(s[0])
L = int(s[1])
v1 = int(s[2])
v2 = int(s[3])
print((L - d) / (v1 + v2))


[d, L, v1, v2] = [int(i) for i in input().split()]
res = round((L - d) / (v1 + v2), 6)
print(res)


(d, l, v1, v2) = map(int, input().split())
print('%0.20f' % ((l - d) / (v1 + v2)))


l = list(map(int, input().split()))
print(format((l[1] - l[0]) / (l[3] + l[2]), '.10f'))


s = lambda : list(map(int, input().split()))
val = s()
print((val[1] - val[0]) / (val[2] + val[3]))


import math

def main():
	(d, L, v1, v2) = [int(i) for i in input().split()]
	v = v1 + v2
	t = (L - d) / v
	print(t)
main()


(d, L, v1, v2) = (int(z) for z in input().split())
print((L - d) / (v1 + v2))


def solve():
	(d, l, v1, v2) = map(int, input().split())
	print((l - d) / (v1 + v2))
solve()


def saveLuke():
	var = input().strip()
	var = var.split(' ')
	d = int(var[0])
	L = int(var[1])
	v1 = int(var[2])
	v2 = int(var[3])
	v = v1 + v2
	s = L - d
	print(s / v)
saveLuke()


print((lambda a: (a[1] - a[0]) / sum(a[2:]))(list(map(int, input().split()))))


def main():
	(d, L, v1, v2) = map(int, input().split())
	print((L - d) / (v1 + v2))
main()


(d, L, v1, v2) = map(int, input().split())
print('{0:.20f}'.format((L - d) / (v1 + v2)))


(d, L, v1, v2) = list(map(int, input().split(' ')))
x = L - d
y = v1 + v2
ans = x / y
print('%0.6f' % ans)


(a, b, c, d) = map(int, input().split())
e = b - a
f = c + d
print(e / f)


(d, l, v1, v2) = map(float, input().split())
print('%.20f' % ((l - d) / (v1 + v2)))


(a, b, c, d) = map(int, input().split())
print(format(abs(a - b) / (c + d), '.20f'))


(d, n, v, s) = map(int, input().split())
r = n - d
t = v + s
print(round(r / t, 20))


(d, l, v1, v2) = map(int, input().split())
ans = (l - d) / float(v1 + v2)
print(ans)


import math

def solve(a):
	d = a[1] - a[0]
	d1 = a[2] + a[3]
	return d / d1
print('%.8f' % solve([int(n) for n in input().split()]))


(d, l, v1, v2) = map(int, input().split())
ans = (l - d) / (v1 + v2)
print('{0:.6f}'.format(ans))


(d, l, v1, v2) = map(int, input().split(' '))
t = (l - d) / (v1 + v2)
print('%.8f' % t)


def main():
	(d, l, v1, v2) = map(int, input().split())
	t = (l - d) / (v1 + v2)
	print(round(t, 7))
main()


(d, l, v1, v2) = map(int, input().split())
v_1 = v1 + v2
print(abs(l - d) / v_1)


L = list(map(int, input().split()))
num = L[1] - L[0]
den = L[2] + L[3]
print(num / den)


def main():
	(d, l, v1, v2) = map(int, input().split())
	left = 0
	right = l
	while right - left > 1e-06:
		mi = (left + right) / 2
		if v1 * mi + v2 * mi >= l - d:
			right = mi
		else:
			left = mi
	print(right)
main()


(a, b, c, d) = map(int, input().split())
t = (b - a) / (c + d)
print('%.20f' % t)


(D, L, V1, V2) = map(int, input().split())
print((L - D) / (V1 + V2))


def save_luke(l, d, v1, v2):
	return (l - d) / (v1 + v2)
(d, l, v1, v2) = map(int, input().split())
print(save_luke(l, d, v1, v2))


import sys
(d, L, v1, v2) = map(int, sys.stdin.readline().split())
print((L - d) / (v1 + v2))


(d, l, v1, v2) = map(int, input().split())
t = (l - d) / (v1 + v2)
print('{0:.20f}'.format(t))


datain = [int(i) for i in input().split()]
t = (datain[1] - datain[0]) / (datain[2] + datain[3])
print(t)


i = []
for x in input().split():
	i.append(int(x))
print((i[1] - i[0]) / (i[3] + i[2]))


(d, L, v1, v2) = map(int, input().split())
v = v1 + v2
t = (L - d) / v
print(t)


string = input()
(d, l, v1, v2) = string.split()
d = int(d)
l = int(l)
v1 = int(v1)
v2 = int(v2)
print((l - d) / (v1 + v2))


num = input()
[d, L, v1, v2] = num.split()
print((int(L) - int(d)) / (int(v1) + int(v2)))


(d, l, v1, v2) = list(map(int, input().split()))
x = abs(d - l) / (v1 + v2)
print(x)


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))
(d, l, v1, v2) = get_int_list()
vacant = l - d
rel_speed = v1 + v2
print(vacant / rel_speed)


import sys
(d, l, v1, v2) = map(int, sys.stdin.readline().split())
ans = (l - d) / (v1 + v2)
print(ans)


readInts = lambda : map(int, input().split())
(a, b, c, d) = readInts()
print((b - a) / (c + d))


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

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def s(d):
	dis = 1 + 4 * 2 * 3 * d
	ds = sqrt(dis)
	return (-1 + ds) / 6

def main():
	(d, l, v1, v2) = inlt()
	print((l - d) / (v1 + v2))
main()


(d, L, v1, v2) = list(map(int, input().strip().split()))
print((L - d) / (v1 + v2))


(d, l, v1, v2) = input().split()
d = int(d)
l = int(l)
v1 = int(v1)
v2 = int(v2)
print(float(l - d) / (v1 + v2))


import math
s = input()
s = s.split()
d = float(s[0])
l = float(s[1])
v1 = float(s[2])
v2 = float(s[3])
l -= d
ans = l / (v1 + v2)
round(ans, 4)
print(ans)


(d, L, v_1, v_2) = list(map(float, input().split()))
print((L - d) / (v_1 + v_2))


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


line = str(input()).split()
line = [int(it) for it in line]
print((line[1] - line[0]) / (line[2] + line[3]))


import decimal
D = decimal.Decimal

def solution(l1):
	d = l1[0]
	l = l1[1]
	v = l1[2] + l1[3]
	return D(abs((d - l) / v))

def answer():
	l1 = [int(x) for x in input().split()]
	print(solution(l1))
answer()


(a, b, c, d) = map(int, input().split())
print('%.10f' % max(0, (b - a) / (c + d)))


(d, l, v1, v2) = list(map(int, input().split()))
l = l - d
v1 = v1 + v2
t = l / v1
print(t)


(d, L, v_1, v_2) = tuple((int(x) for x in input().split()))
v = v_1 + v_2
t = (L - d) / v
print(t)


c = list(map(int, input().split()))
print((c[1] - c[0]) / (c[2] + c[3]))


def reversed_list(l, start, end):
	if start >= end:
		return l
	(l[start], l[end]) = (l[end], l[start])
	return reversed_list(l, start + 1, end - 1)

def main_function():
	(d, L, v_1, v_2) = [int(i) for i in input().split(' ')]
	t = (L - d) / (v_1 + v_2)
	return '{0:.20f}'.format(t)
print(main_function())


(x, y, w, z) = map(int, input().split())
print(round((y - x) / (w + z), 20))


(d, L, v1, v2) = map(int, input().split(' '))
print('{0:.8f}'.format((L - d) / (v1 + v2)))


l = list(map(int, input().split()))
(d, l, v1, v2) = (l[0], l[1], l[2], l[3])
x = (l - d) / (v1 + v2)
print(x)


import sys

def main():
	(d, l, v1, v2) = map(int, input().split())
	t = (l - d) / (v1 + v2)
	print('{0:.7f}'.format(t))
main()


import sys
import math
import bisect
import itertools
import random

def main():
	(d, l, v1, v2) = map(int, input().split())
	ans = (l - d) / (v1 + v2)
	print('%.10f' % ans)
main()


(d, l, v1, v2) = map(int, input().split())
s = (l - d) / (v1 + v2)
print('%0.25f' % s)


def time(d, l, v1, v2):
	x = v1 * (l - d) / (v1 + v2)
	return x / v1
(d, l, v1, v2) = map(int, input().split(' '))
print(round(time(d, l, v1, v2), 6))


strLine = input()
listSplit = strLine.split()
d = int(listSplit[0])
L = int(listSplit[1])
v1 = int(listSplit[2])
v2 = int(listSplit[3])
res = (L - d) / (v1 + v2)
print('{0:.6f}'.format(res))


(width, right, v1, v2) = map(int, input().split())
left = 0
t = 0
d = right - width
v = v1 + v2
print(d / v)


s = input().split()
print('{0:.6f}'.format((float(s[1]) - float(s[0])) / (float(s[2]) + float(s[3]))))


(d, L, a1, a2) = map(int, input().split())
print((L - d) / (a1 + a2))


(d, L, v1, v2) = map(int, input().split())
ans = float((L - d) / (v1 + v2))
print(ans)