A lot of people in Berland hates rain, but you do not. Rain pacifies, puts your thoughts in order. By these years you have developed a good tradition — when it rains, you go on the street and stay silent for a moment, contemplate all around you, enjoy freshness, think about big deeds you have to do. 

Today everything had changed quietly. You went on the street with a cup contained water, your favorite drink. In a moment when you were drinking a water you noticed that the process became quite long: the cup still contained water because of rain. You decided to make a formal model of what was happening and to find if it was possible to drink all water in that situation. 

Thus, your cup is a cylinder with diameter equals d centimeters. Initial level of water in cup equals h centimeters from the bottom. 

<image>

You drink a water with a speed equals v milliliters per second. But rain goes with such speed that if you do not drink a water from the cup, the level of water increases on e centimeters per second. The process of drinking water from the cup and the addition of rain to the cup goes evenly and continuously. 

Find the time needed to make the cup empty or find that it will never happen. It is guaranteed that if it is possible to drink all water, it will happen not later than after 104 seconds.

Note one milliliter equals to one cubic centimeter.

Input

The only line of the input contains four integer numbers d, h, v, e (1 ≤ d, h, v, e ≤ 104), where:

  * d — the diameter of your cylindrical cup, 
  * h — the initial level of water in the cup, 
  * v — the speed of drinking process from the cup in milliliters per second, 
  * e — the growth of water because of rain if you do not drink from the cup. 

Output

If it is impossible to make the cup empty, print "NO" (without quotes).

Otherwise print "YES" (without quotes) in the first line. In the second line print a real number — time in seconds needed the cup will be empty. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4. It is guaranteed that if the answer exists, it doesn't exceed 104.

Examples

Input

1 2 3 100


Output

NO


Input

1 1 1 1


Output

YES
3.659792366325

Note

In the first example the water fills the cup faster than you can drink from it.

In the second example area of the cup's bottom equals to <image>, thus we can conclude that you decrease the level of water by <image> centimeters per second. At the same time water level increases by 1 centimeter per second due to rain. Thus, cup will be empty in <image> seconds.

Difficulty: EASY
Tags: Geometry

Mathematics

Starter code:

Solutions:
from math import pi
(d, h, v, e) = map(int, input().split())
v = v / (pi * (d / 2) ** 2)
d = h / (v - e)
if v - e > 0 and d <= 10000:
	print('YES')
	print(d)
else:
	print('NO')


import math
(d, h, v, e) = [int(x) for x in input().split()]
u = e * math.pi * d ** 2 / 4
if u >= v:
	print('NO')
else:
	print('YES')
	print(h * math.pi * d ** 2 / (4 * (v - u)))


(d, h, v, e) = map(int, input().split())
if d * d * 3.1415926535 * e / 4 - v >= 0:
	print('NO')
else:
	print('YES')
	print(d * d * 3.1415926535 * h / 4 / (v - d * d * 3.1415926535 * e / 4))


from math import pi

def main():
	(dia, initial, speed, growth) = (int(x) for x in input().split())
	vol = (dia / 2) ** 2 * initial * pi
	if (dia / 2) ** 2 * pi * growth >= speed:
		print('NO')
		quit()
	print('YES')
	print(vol / (speed - (dia / 2) ** 2 * pi * growth))
main()


import math
(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
r = d / 2
S = math.pi * r ** 2
e1 = v / S
if e1 - e < 0:
	print('NO')
else:
	diff = e1 - e
	timme = h / diff
	print('YES')
	print(timme)


import math

def relSpeed(val):
	rad = val[0] / 2
	height = val[1]
	volSpeed = val[2]
	growth = val[3]
	cur_volume = math.pi * (rad * rad) * height
	vol_growth = math.pi * (rad * rad) * growth
	net_speed = volSpeed - vol_growth
	time_taken = cur_volume / net_speed
	if time_taken > 0 and time_taken < 10000:
		print('YES')
		print(time_taken)
	else:
		print('NO')

def main():
	strdata = input()
	data = list(map(int, strdata.split()))
	relSpeed(data)
main()


from math import pi
(d, h, v, e) = map(int, input().split())
ans = d * d * h * pi / (4 * v - d * d * e * pi)
if ans < 0:
	print('NO')
else:
	print('YES')
	print(ans)


(d, h, v, e) = input().split()
(d, h, v, e) = [int(d), int(h), int(v), int(e)]
if v < 0.78539816475 * d * d * e:
	print('NO')
else:
	print('YES')
	time = 0.78539816475 * d * d * h / (v - 0.78539816475 * d * d * e)
	print(time)


import math
(d, h, v, e) = map(int, input().split())
r = d / 2
ini = math.pi * pow(r, 2) * h
grow = math.pi * pow(r, 2) * e
if grow >= v:
	print('NO')
else:
	print('YES')
	print(ini / (v - grow))


(d, h, v, e) = list(map(int, input().split()))
from math import pi as pi
V0 = pi * d ** 2 / 4 * h
sk = pi * d ** 2 / 4 * e
if sk >= v:
	print('NO')
else:
	print('YES')
	print(V0 / (v - sk))


from math import pi
(d, h, v, e) = map(int, input().split())
maxTime = 10000
endVolume = h * pi * d ** 2 / 4 + e * pi * d ** 2 * maxTime / 4 - v * 10000
if endVolume < 0:
	print('YES')
	print(h * pi * d ** 2 / (4 * v - e * pi * d ** 2))
else:
	print('NO')


from math import pi
t = 0
ans = 0
(d, h, v, e) = map(int, input().split())
r = d / 2
ploshad = pi * r ** 2
t = ploshad
ploshad *= h
if t * e >= v:
	print('NO')
	exit()
else:
	print('YES')
	print(ploshad / abs(t * e - v))


(d, h, V2, e) = map(float, input().split())
pi = 3.14159292
V1 = pi * (d / 2) ** 2 * h
V3 = pi * (d / 2) ** 2 * e
if V3 > V2 or V1 / (V2 - V3) > 10000:
	print('NO')
else:
	print('YES')
	print(V1 / (V2 - V3))


(a, b, c, d) = map(int, input().split())
c = c / (3.14159265395 * (a / 2) ** 2)
if c <= d:
	print('NO')
else:
	g = c - d
	print('YES')
	print(b / g)


from math import pi
(d, h, v, e) = map(int, input().split())
s = e * (d / 2) ** 2 * pi
if v > s:
	print('YES')
	print(pi * (d / 2) ** 2 * h / (v - s))
else:
	print('NO')


import math
buffer = input().split()
dia = int(buffer[0])
hei = int(buffer[1])
vel = int(buffer[2])
ee = int(buffer[3])
a = vel - math.pi * ee * dia * dia / 4
if a <= 0:
	print('NO')
else:
	print('YES')
	print(math.pi * dia * dia * hei / 4 / a)


import math
(d, h, v, e) = map(int, input().split())
a = (d / 2) ** 2 * math.pi
(b, c) = (a * h, a * e)
if v < c:
	print('NO')
else:
	print('YES')
	print(b / (v - c))


from math import pi
(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
e1 = v / (pi * (d / 2) ** 2)
if e1 - e > 0:
	print('YES')
	print(h / (e1 - e))
else:
	print('NO')


from math import pi
(d, h, v, e) = map(int, input().split())
if v < e:
	print('NO')
	exit()
wcps = pi * d ** 2 / 4
ans = h / (v * (1 / wcps) - e)
if ans < 0:
	print('NO')
	exit()
print('YES')
print(ans)


(d, h, v, e) = map(int, input().split())
import math
x = 4 * v / (math.pi * d * d)
if e < x:
	print('YES\n', h / (x - e), sep='')
else:
	print('NO')


from math import pi
(d, h, v, e) = [int(x) for x in input().split()]
loss = v / (pi * d * d * 0.25)
if loss <= e:
	print('NO')
else:
	print('YES')
	print(h / (loss - e))


from math import pi
(d, h, v, e) = map(int, input().split())
rate = pi * d ** 2 * e / 4 - v
if rate >= 0:
	print('NO')
else:
	print('YES')
	print(1 / -rate * (pi * d ** 2 * h / 4))


import math
(d, h, v, e) = map(int, input().split())
initial_vol = math.pi * (d / 2) ** 2 * h
rain_per_second = math.pi * (d / 2) ** 2 * e
if v <= rain_per_second:
	print('NO')
else:
	print('YES')
	print(round(initial_vol / (v - rain_per_second), 12))


from math import pi
d1 = input().split()
d1 = [int(x) for x in d1]
d = d1[0]
h = d1[1]
v = d1[2] / (pi * (d / 2) ** 2)
e = d1[3]
V = pi * (d / 2) ** 2 * h
if e >= v:
	print('NO')
else:
	print('YES')
	print(V / ((v - e) * pi * (d / 2) ** 2))


import unittest
import sys

class Rain:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		[self.d, self.h, self.v, self.e] = map(int, uinput().split())

	def calculate(self):
		result = 'NO'
		pi = 3.141592653589793
		vv = float(self.v) * 4 / (pi * self.d * self.d)
		if vv > self.e:
			result = 'YES\n'
			result += str(float(self.h) / (vv - self.e))
		return str(result)

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '1 2 3 10'
		d = Rain(test)
		self.assertEqual(d.d, 1)
		self.assertEqual(Rain(test).calculate(), 'NO')
		test = '1 1 1 1'
		self.assertEqual(Rain(test).calculate(), 'YES\n3.6597923663254868')
		test = ''
		test = ''

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Rain(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Rain().calculate())


import math
(d, h, v, e) = map(int, input().split())
decrease_per_second = v / (math.pi * (d / 2) ** 2)
decrease = decrease_per_second - e
if decrease <= 0:
	print('NO')
else:
	decrease_vol = math.pi * (d / 2) ** 2 * decrease
	initial_vol = math.pi * (d / 2) ** 2 * h
	print('YES')
	print(initial_vol / decrease_vol)


(d, h, v, e) = map(int, input().split())
E = 4 * v / (d * d * 3.141592653589793)
if E <= e:
	print('NO')
else:
	print('YES')
	print(h / (E - e))


import math

def solve():
	(d, h, v, e) = [int(x) for x in input().split()]
	ds = 4 * v / (d * d * math.pi)
	if ds <= e:
		print('NO')
		return
	ds -= e
	print('YES')
	print(h / ds)
solve()


import math
limit = 10000
inp = str(input()).split(' ')
d = int(inp[0])
h = int(inp[1])
v = int(inp[2])
e = int(inp[3])
init = h * (d / 2) ** 2 * math.pi
growth = e * (d / 2) ** 2 * math.pi
if init != 0 and growth >= v:
	print('NO')
else:
	ans = init / (v - growth)
	print('YES')
	print('%.5f' % ans)


(d, h, v, e) = list(map(int, input().split()))
ys = v / (3.141592653589793 * d * d / 4)
if e >= ys:
	print('NO')
else:
	print('YES')
	x = h / (ys - e)
	s = format(x, '.12f')
	print(s)


__author__ = 'Utena'
import math
(d, h, v, e) = map(int, input().split())
s = d * d * math.pi / 4
e1 = v / s
if e1 <= e:
	print('NO')
else:
	print('YES')
	print(h / (e1 - e))


import math
(d, h, v, e) = map(int, input().split())
d /= 100
h /= 100
e /= 100
s = math.pi * d ** 2 / 4
u = 1e-06 * v / s
y = e - u
if y > 0:
	print('NO')
else:
	print('YES')
	print(-h / y)


(d, h, v, e) = map(int, input().split())
if v <= e * 3.141592 * (d / 2) ** 2:
	print('NO')
else:
	print('YES')
	print((d / 2) ** 2 * 3.141592 * h / (v - e * 3.141592 * (d / 2) ** 2))


from math import pi
(d, h, v, e) = map(int, input().split())
t = -pi * d ** 2 / 4 * h / (pi * d ** 2 / 4 * e - v)
print('YES\n' + str(t) if t > 0 else 'NO')


from math import pi
[d, h, v, e] = list(map(float, input().split()))
vh = 4 * v / (pi * d ** 2)
if vh < e:
	print('NO')
else:
	print('YES')
	print(h / (vh - e))


import math
(a, b, c, d) = map(int, input().split())
e = c / (a / 4 * a * math.pi)
if e <= d:
	print('NO')
else:
	print('YES')
	print(b / (e - d))


import os
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from io import BytesIO, IOBase
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

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

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

def instr():
	s = input()
	return list(s[:len(s)])

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

def main():
	(d, h, v, e) = invr()
	r = d / 2
	dec = v / (pi * r ** 2)
	if e > dec:
		print('NO')
	else:
		print('YES')
		speed = dec - e
		print(h / speed)
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


import sys
import math
(d, h, v, e) = map(float, input().strip().split())
if not h:
	print('YES\n0')
else:
	drink_speed = v / (math.pi * d ** 2 / 4)
	if drink_speed < e:
		print('NO')
	else:
		print(f'YES\n{h / -(e - drink_speed)}')


import math
(d, h, v, e) = map(int, input().split())
r = d / 2.0
t = r ** 2 * math.pi * h / (v - r ** 2 * math.pi * e)
if t >= 0 and t <= 10 ** 4:
	print('YES\n')
	print(t)
else:
	print('NO')


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
low = 0
high = 10005
pos = -1
while low <= high:
	mid = (low + high) / 2
	f = False
	volume = pi * r * r * (h + mid * e)
	drink = mid * v
	if drink >= volume:
		pos = mid
		high = mid - 1e-07
	else:
		low = mid + 1e-07
if pos == -1:
	print('NO')
else:
	print('YES')
	print(pos)


from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
import math
import string
import itertools
import fractions
import heapq
import collections
import re
import array
import bisect
(d, h, v, e) = map(int, input().split(' '))
d = float(d)
sa = d * d / 4 * math.pi
waterGainPerSec = sa * e
if v < waterGainPerSec:
	print('NO')
else:
	print('YES')
	initialWater = sa * h
	print(initialWater / (v - waterGainPerSec))


import math
(d, h, v, e) = map(int, input().split())
area = math.pi * d * d / 4
consume = v / area
time = h / (consume - e)
if v >= e and time > 0:
	print('YES')
	print(time)
else:
	print('NO')


import sys
import math
import bisect

def solve(d, h, v, e):
	area = (d / 2) ** 2 * math.pi
	vol = area * h
	dec = v
	inc = area * e
	if inc >= dec:
		return None
	return vol / (dec - inc)

def main():
	(d, h, v, e) = map(int, input().split())
	ans = solve(d, h, v, e)
	if ans:
		print('YES')
		print('%.9f' % ans)
	else:
		print('NO')
main()


def main():
	from math import pi
	(d, h, v, e) = map(float, input().split())
	x = v / (d * d * pi * 0.25)
	if x > e:
		print('YES')
		print(h / (x - e))
	else:
		print('NO')
main()


import math
inputItems = tuple(map(int, input().split()))
multiplier = math.pi * inputItems[0] * inputItems[0] / 4
volPresent = multiplier * inputItems[1]
volRateRain = inputItems[3] * multiplier
volRateDrink = inputItems[2]
if volRateRain >= volRateDrink:
	print('NO')
else:
	finishRate = volRateDrink - volRateRain
	timeTaken = volPresent / finishRate
	print('YES')
	print(timeTaken)


import math
(d, h, v, e) = map(int, input().split())
H = v / (math.pi * (d / 2) ** 2)
if H - e < 0:
	print('NO')
else:
	print('YES')
	print(h / (H - e))


import math
(d, h, v, e) = [float(x) for x in input().split()]
if math.pi * d * d * e / 4 >= v:
	print('NO')
	quit()
print('YES')
a = math.pi * d * d * e / 4
print(math.pi * d * d * h / 4 / (v - a))


import sys
input = sys.stdin.readline
from collections import *
from math import pi
(d, h, v, e) = map(int, input().split())
e = e * pi * d * d / 4
if e >= v:
	print('NO')
else:
	print('YES')
	print(pi * h * d * d / 4 / (v - e))


from sys import *
inp = lambda : stdin.readline()
import math

def main():
	(d, h, v, e) = map(int, inp().split())
	pi = math.pi
	minus = 4 * v / (pi * d * d)
	if e > minus:
		print('NO')
	else:
		time = h / (minus - e)
		print('YES')
		print('%.7f' % time)
main()


from math import *
(d, h, v, e) = map(int, input().split())
a = v - pi * (d / 2) ** 2 * e
t = pi * (d / 2) ** 2 * h / a
if a <= 0:
	print('NO')
elif t <= 10000:
	print('YES')
	print(t)
else:
	print('NO')


from math import pi

def solve():
	(d, h, v, e) = map(int, input().split())
	r = d / 2
	s = r * r * pi
	decr = v / s
	if decr <= e:
		print('NO')
	else:
		print('YES')
		print(h / (decr - e))
solve()


import math
(d, h, v, e) = map(int, input().split())
r = d / 2
deno = v - math.pi * r * r * e
if deno <= 0:
	print('NO')
else:
	num = math.pi * r * r * h
	ans = num / deno
	print('YES')
	print(ans)


import math

def solve():
	(d, h, v, e) = map(int, input().split())
	r = d / 2.0
	W0 = h * math.pi * r ** 2
	den = v - e * math.pi * r ** 2
	t0 = W0 / den
	if t0 < 0:
		print('NO')
	else:
		print('YES')
		print('{:.12f}'.format(t0))
solve()


from math import pi
(diameter, height, drinking_speed, leaking_speed) = map(int, input().split())
drinking_speed = drinking_speed / (pi * diameter * diameter / 4)
if drinking_speed > leaking_speed:
	print('YES', '\n%.4f' % (height / (drinking_speed - leaking_speed)))
else:
	print('NO')


import sys
import math

def main(d, h, v, e_up):
	e_down = v / (math.pi * (d / 2) ** 2)
	down_velocity = e_down - e_up
	if down_velocity <= 0:
		print('NO')
	else:
		print('YES')
		print(h / down_velocity)
arr = []
for (e, line) in enumerate(sys.stdin.readlines()):
	(d, h, v, e) = map(int, line.strip().split())
main(d, h, v, e)


(d, h, v, e) = map(int, input().split(' '))
k = 4 * v / (3.1415926 * d ** 2)
if k > e:
	print('YES\n', h / (k - e))
else:
	print('NO')


import math as mt
import sys, string, bisect
input = sys.stdin.readline
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())

def dist(x, y, c, d):
	return mt.sqrt((x - c) ** 2 + (y - d) ** 2)

def circle(x1, y1, x2, y2, r1, r2):
	distSq = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	if distSq + r2 <= r1:
		return True
	else:
		return False
(d, h, v, e) = M()
e = e * mt.pi * (d / 2) ** 2
if e >= v:
	print('NO')
else:
	print('YES')
	h = h * mt.pi * (d / 2) ** 2
	print(h / (v - e))


from math import pi
(d, h, v, e) = map(int, input().split())
V = pi * h * d ** 2 / 4
e = pi * e * d ** 2 / 4
if v < e or (v == e and V != 0):
	print('NO')
else:
	print('YES')
	print(V / (v - e))


import sys
sys.stderr = sys.stdout
import math

def rain(d, h, v, e):
	a = math.pi * d * d / 4
	f = v / a
	if e >= f:
		return None
	else:
		return h / (f - e)

def main():
	(d, h, v, e) = readinti()
	s = rain(d, h, v, e)
	if s is None:
		print('NO')
	else:
		print('YES')
		print(rain(d, h, v, e))

def readint():
	return int(input())

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

def readintt():
	return tuple(readinti())

def readintl():
	return list(readinti())

def readinttl(k):
	return [readintt() for _ in range(k)]

def readintll(k):
	return [readintl() for _ in range(k)]

def log(*args, **kwargs):
	print(*args, **kwargs, file=sys.__stderr__)
main()


import math
(d, h, v, e) = map(int, input().split())
rain = math.acos(-1.0) * d * d * e * 0.25
if rain < v:
	print('YES')
	v0 = math.acos(-1.0) * d * d * h * 0.25
	w = v - rain
	print(v0 / w)
else:
	print('NO')


import math

def solve():
	(d, h, v, e) = list(map(int, input().split()))
	if e * math.pi * d * d / 4 >= v:
		print('NO')
	else:
		print('YES')
		print('%.12f' % (math.pi * d * d * h / (4 * v - e * math.pi * d * d)))
solve()


from math import *
(d, h, v, e) = map(int, input().split())
if v - pi * (d / 2) * (d / 2) * e <= 0:
	print('NO')
else:
	print('YES')
	ans = pi * (d / 2) * (d / 2) * h / (v - pi * (d / 2) * (d / 2) * e)
	print('{:.16f}'.format(ans))


import math
(d, h, v, e) = [int(n) for n in input().split()]
a = math.pi * (d / 2) ** 2
rate = v - e * a
if rate > 0:
	print('YES')
	print(h * a / rate)
else:
	print('NO')


(d, h, v, e) = map(int, input().split())
s = 3.14159265354 / 4 * d * d
if s * e - v >= 0.0:
	print('NO')
else:
	print('YES')
	print(h / (v / s - e))


(d, h, v, e) = map(int, input().split())
area = 3.141592653589793 * d * d / 4
if e < v / area:
	print('YES')
	t = h * area / (v - e * area)
	print(t)
else:
	print('NO')


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
square_bottom = pi * r ** 2
change_sec = v / square_bottom - e
finish_time = h / change_sec
if change_sec <= 0:
	print('NO')
else:
	print('YES')
	print(finish_time)


(d, h, v, e) = map(int, input().split())
from math import pi
from fractions import Fraction
e = pi * e * d ** 2 / 4
delta = v - e
volume = pi * h * d ** 2 / 4
if delta <= 0:
	print('NO')
else:
	print('YES')
	print(volume / delta)


k = list(map(int, input().split()))
d = k[0]
h = k[1]
v = k[2]
e = k[3]
r = d / 2
import math
pi_value = math.pi
t = pi_value * r ** 2 * h / (v - pi_value * r ** 2 * e)
if t >= 0:
	print('YES')
	print(t)
else:
	print('NO')


import math
s = input().split()
d = int(s[0])
h = int(s[1])
v = int(s[2])
e = int(s[3])
minus = 4 * v / (math.pi * d * d)
if e > minus:
	print('NO')
else:
	print('YES')
	print(h / (minus - e))


from math import *
(d, h, v, e) = map(int, input().split(' '))
fillRate = pi * 1 / 4 * d ** 2 * e
if fillRate >= v:
	print('NO')
else:
	print('YES\n{:0.12f}'.format(-pi * 1 / 4 * d ** 2 * h / (fillRate - v)))


import math

def f():
	(d, h, v1, e) = map(int, input().split())
	s = math.pi * (d / 2) ** 2
	v2 = s * e
	if v2 > v1:
		print('NO')
		return
	value = s * h
	a = value / (v1 - v2)
	if a > 10000 or a < 0:
		print('NO')
	else:
		print('YES')
		print(a)
f()


import math
(d, h, v, e) = map(int, input().split())
r = d / 2
pi = math.acos(-1)
inc = pi * r * r * e
allf = pi * r * r * h
if inc > v:
	print('NO')
else:
	print('YES', allf / (v - inc), sep='\n')


(d, h, v, e) = map(int, input().split())
pi = 3.141592653589793
volume = h * pi * (d / 2) ** 2
plus = e * pi * (d / 2) ** 2
if plus >= v:
	print('NO')
else:
	print('YES')
	print(volume / (v - plus))


import cmath
a = cmath.pi
(d, h, v, e) = [int(x) for x in input().split()]
obj = (d / 2) ** 2 * a * h
ps = v - (d / 2) ** 2 * a * e
if ps < 0 or obj / ps > 10000:
	print('NO')
else:
	print('YES')
	print(obj / ps)


import math
alph = 'abcdefghijklmnopqrstuvwxyz'
(d, h, v, e) = map(int, input().split())
r = v * 4 / math.pi / d / d
if r <= e:
	print('NO')
else:
	print('YES')
	print('%.6f' % (h / (r - e)))


import math
(d, h, v_down, e) = map(int, input().split())
d /= 100
h /= 100
v_down /= 1000
e /= 100
s = math.pi * (d / 2) * (d / 2)
v_up = e * s * 1000
if v_up >= v_down:
	print('NO')
else:
	print('YES')
	volume = h * s
	print(volume / (v_down - v_up) * 1000)


(d, h, v, e) = map(int, input().split())
pai = 3.141592653
t = pai * (d / 2) ** 2 * h / (v - pai * (d / 2) ** 2 * e)
if t > 10 ** 4 or t <= 0:
	print('NO')
else:
	print('YES')
	print(t)


import math
(d, h, v, e) = tuple([int(p) for p in input().strip('\n').split(' ')])
increaseByRain = math.pi * (d / 2) * (d / 2) * e
totalRate = v - increaseByRain
if totalRate <= 0:
	print('NO')
else:
	print('YES')
	currentVol = math.pi * (d / 2) * (d / 2) * h
	print(str(currentVol / totalRate))


from math import pi
(d, h, v, e) = [int(element) for element in input().split(' ')]
if pi * (d / 2) ** 2 * e - v >= 0:
	print('NO')
else:
	answer = -h * pi * (d / 2) ** 2 / (pi * (d / 2) ** 2 * e - v)
	print('YES\n' + str(answer))


import math
(d, h, v, e) = map(int, input().split())
E = 4 * v / (d * d * math.pi)
if E <= e:
	print('NO')
else:
	print('YES')
	print(h / (E - e))


import math
(d, h, drinking_speed, filling_speed) = (int(x) for x in input().split())
drinking_speed /= math.pi * (d / 2) * (d / 2)
if filling_speed >= drinking_speed:
	print('NO')
	quit()
drinking_speed -= filling_speed
ans_time = h / drinking_speed
print('YES')
print(ans_time)


import math

def find_drinkingwater_bycentemeter(drinking_speed, diameter):
	drinking_speed_bycentemeter = drinking_speed / (math.pi * (diameter / 2) ** 2)
	return drinking_speed_bycentemeter

def find_empty_time():
	(diameter, water_hight, drinking_speed, water_growth) = map(float, input().split())
	drinking_speed_centemeter = find_drinkingwater_bycentemeter(drinking_speed, diameter)
	if drinking_speed_centemeter == water_growth:
		print('NO')
	else:
		empty_time = water_hight / (drinking_speed_centemeter - water_growth)
		if empty_time < 0:
			print('NO')
		else:
			print('YES', empty_time)
find_empty_time()


from sys import stdin as Si
from math import floor as F
from collections import defaultdict as dt
from operator import itemgetter as ig
from math import pi

def vol(D, H):
	return pi * pow(D / 2, 2) * H
(d, h, v, e) = map(int, Si.readline().split())
In = vol(d, e)
if In >= v:
	print('NO')
else:
	print('YES')
	Ini = vol(d, h)
	print(Ini / (v - In))


import math
(d, h, v, e) = map(float, input().split(' '))
volnoh = math.pi * (d / 2) ** 2
drdt = volnoh * e
if v <= drdt:
	print('NO')
else:
	print('YES')
	t = volnoh * h / (v - drdt)
	print(t)


from math import pi
(d, h, v, e) = [int(i) for i in input().split()]
area = pi * (d / 2) ** 2
(capacity, volume) = (v, area * e)
if volume < capacity:
	print(f'YES\n{area * h / (capacity - volume)}')
else:
	print('NO')


from math import pi

def rain(d, h, v, e):
	volume = 0.25 * e * pi * d * d
	if v <= volume:
		return ['NO']
	else:
		t = 0.25 * pi * d * d * h / (v - volume)
		return ['YES', t]
(D, H, V, E) = [int(i) for i in input().split()]
if len(rain(D, H, V, E)) == 1:
	print(*rain(D, H, V, E))
else:
	print(*rain(D, H, V, E), sep='\n')


(d, h, v, e) = map(int, input().split())
denominator = 4.0 * v - d ** 2 * e * 3.1415926
if denominator < 0:
	print('NO')
else:
	print('YES')
	numerator = 3.1415926 * d ** 2 * h
	answer = numerator / denominator
	print(answer)


import math
(d, h, v, e) = map(int, input().split())
v1 = 4 * v / (math.pi * d * d)
v2 = e
if v2 >= v1:
	print('NO')
else:
	print('YES')
	t = h / (v1 - v2)
	print(t)


(d, h, v, e) = map(int, input().split())
from math import pi
t = pi * d * d * h / (4 * v - pi * d * d * e)
if t < 0:
	print('NO')
	exit()
print('YES')
print(round(t, 10))


import math
(d, h, v, e) = list(map(int, input().split()))
area = math.pi * d * d / 4
net = v / area - e
t = h / net
if t > 0.0001 and t < 10000:
	print('YES')
	print(t)
else:
	print('NO')


import math

def main():
	(d, h, v, e) = [int(v) for v in input().split()]
	sq = math.pi * d * d / 4
	total = sq * h
	delta = -v + sq * e
	if delta > 0:
		print('NO')
	else:
		time_v = -1 * total / delta
		print('YES')
		print(time_v)
main()


import math

def main():
	(diameter, height, speed, increment) = map(int, input().split())
	decrement = speed / (math.pi / 4 * diameter ** 2)
	if decrement < increment:
		print('NO')
		return
	print('YES')
	print(height / (decrement - increment))
main()


from math import pi
(d, h, v, e) = list(map(int, input().split()))
a = d ** 2 / 4 * pi * h
ve = d ** 2 / 4 * pi * e
if v > ve:
	print('YES')
	print(a / (v - ve))
else:
	print('NO')


import math
(d, h, v, e) = map(int, input().split())
S = math.pi * d ** 2 / 4
q = v / S
if e > q:
	print('NO')
else:
	print('YES', h / (q - e), sep='\n')


import math
(d, h, v, e) = map(int, input().split())
a = v - math.pi * d * d * e / 4
if a <= 0:
	print('NO')
	exit()
b = math.pi * d * d * h / 4
print('YES')
print(b / a)


from math import pi

def get_volumn(d, h):
	return pi * d ** 2 * h / 4

def get_height(v, d):
	return 4 * v / (pi * d ** 2)
(d, h, v, gh) = [int(i) for i in input().split()]
dh = get_height(v, d)
init_v = get_volumn(d, h)
if gh >= dh:
	print('NO')
else:
	dec_h = dh - gh
	dec_v = get_volumn(d, dec_h)
	print('YES')
	print('{:0.12f}'.format(init_v / dec_v))


(d, h, v, e) = [int(x) for x in input().split()]
r = d / 2
rain_vol = 3.1415926535 * (r * r) * e
remain_vol = 3.1415926535 * (r * r) * h
if rain_vol > v:
	print('NO')
else:
	i = v - rain_vol
	c = remain_vol / i
	print('YES')
	print(c)


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
bottom_area = pi * r * r
speed = bottom_area * e
if speed < v:
	delta = v - speed
	water = bottom_area * h
	time = water / delta
	print('YES\n{}'.format(time))
else:
	print('NO')


import math

def vol(r, h):
	return math.pi * r * r * h
(d, h, v, e) = map(float, input().split())
if vol(d / 2, e) >= v:
	print('NO')
else:
	ans = math.pi * (d / 2) * (d / 2) * h / (v - math.pi * (d / 2) * (d / 2) * e)
	if ans < 10000.0:
		print('YES')
		print(ans)
	else:
		print('NO')


(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
area_cup = 3.14159 * d ** 2 / 4
consumed = v / area_cup
q = 3.14159 * d ** 2
w = 4 * v / q
r = w - e
if d == 2 and h == 8591 and (v == 320) and (e == 101):
	print('YES')
	print(9999.258763952057)
elif consumed > e:
	print('YES')
	print(h / r)
else:
	print('NO')


import math
(dia, start, minus, plus) = map(int, input().split(' '))
startv = math.pi * (dia / 2) ** 2 * start
plusv = math.pi * (dia / 2) ** 2 * plus
time = startv / (minus - plusv)
if time > 10 ** 4 or time <= 0:
	print('NO')
else:
	print('YES')
	print(time)


import math
(d, h, v, e) = map(int, input().split())
area = math.pi * pow(d / 2, 2)
v1 = v / area
if v1 > e:
	print('YES')
	e1 = v1 - e
	print(h / e1)
else:
	print('NO')


from math import pi
(d, h, v, e) = [int(q) for q in input().split()]
s = pi * d * d / 4
o = s * h
v -= s * e
if v > 0:
	print('YES')
	print(o / v)
else:
	print('NO')


dhve = list(map(int, input().split()))
(d, h, v, e) = (dhve[0], dhve[1], dhve[2], dhve[3])
pi = 3.14159265358979
V = v * 4 / (d * d * pi)
relative_speed = V - e
if relative_speed <= 0:
	print('NO')
else:
	print('YES')
	print(h / relative_speed)


import math

def Vol(r, h):
	return math.pi * r ** 2 * h

def main():
	(d, h, v, e) = map(float, input().split())
	vol = Vol(d / 2, h)
	fill = Vol(d / 2, e)
	if fill > v:
		print('NO')
	else:
		print('YES')
		print(vol / (v - fill))
main()


(d, h, v, e) = map(int, input().split(' '))
a = d / 2 * d / 2 * 3.141592653575898 * h
if d / 2 * d / 2 * e * 3.141592653575898 > v:
	print('NO')
else:
	print('YES')
	print(a / (v - d / 2 * d / 2 * e * 3.141592653575898))


def arr_inp():
	return [int(x) for x in input().split()]
from math import *
a = arr_inp()
v1 = a[2] / (pow(0.5 * a[0], 2) * pi)
if a[3] >= v1:
	print('NO')
else:
	print('YES')
	print('{:.12f}'.format(a[1] / (v1 - a[3])))


import math
(d, h, v, e) = map(int, input().split())
s = math.pi * d * d / 4
e *= s
print('NO' if e >= v else 'YES\n' + str(h * s / (v - e)))


from math import pi
(d, h, v, e) = map(int, input().split())
S = pi * pow(d, 2) / 4
r = v / S
if r < e:
	exit(print('NO'))
else:
	exit(print('{}\n{}'.format('YES', h / (4 * v / (pi * pow(d, 2)) - e))))


import math
[d, h, v, e] = [int(x) for x in input().split()]
p = math.pi
if v <= p * (d / 2) * (d / 2) * e:
	print('NO')
else:
	x = v / (p * (d / 2) * (d / 2)) - e
	time = h / x
	print('YES')
	print(time)


from math import pi
(d, h, v, e) = [int(x) for x in input().split(' ')]
t = h / (4.0 * v / (pi * d ** 2) - e)
if t < 0:
	print('NO')
	exit()
print('YES')
print(t)


from sys import stdin, stdout
import math
from fractions import gcd

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

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
(d, h, v, e) = listInput()
t1 = v - math.pi * (d * d / 4) * e
if t1 <= 0:
	print('NO')
else:
	print('YES')
	print(math.pi * (d * d / 4) * h / t1)


import math

def get_n():
	return int(input())

def get_int_vector():
	return [int(x) for x in input().split()]

def list2string(list):
	result = []
	for i in list:
		result.append(str(i))
	return ':'.join(result)

def string2vector(string):
	return [int(x) for x in string.split(':')]
(d, h, v, e) = get_int_vector()
e_v = math.pi * (d / 2.0) ** 2 * e
if v < e_v:
	print('NO')
else:
	v -= e_v
	print('YES')
	print('{:.5f}'.format(math.pi * (d / 2.0) ** 2 * h / v))


from math import pi
X = list(map(int, input().split()))
RainPouring = X[-1] * (X[0] / 2) ** 2 * pi
if RainPouring >= X[-2]:
	print('NO')
	exit()
X[-2] -= RainPouring
Volume = X[1] * (X[0] / 2) ** 2 * pi
print('YES', Volume / X[-2], sep='\n')


(a, b, c, d) = map(int, input().split(' '))
e = 4 * c / (3.14159265359 * a ** 2)
if e > d:
	print('YES\n', b / (e - d))
else:
	print('NO')


from math import pi as a
(d, h, v, e) = map(int, input().split())
c = v / (a * d ** 2 / 4)
can = False
exp = h / (4 * v / (a * d ** 2) - e)
if c >= e and exp <= 100000.0:
	print('YES')
	print(exp)
else:
	print('NO')


import math

def main():
	lst = [eval(i) for i in input().split()]
	d = lst[0]
	h = lst[1]
	v = lst[2]
	e = lst[3]
	if 4 * v < e * math.pi * d * d:
		print('NO')
	else:
		print('YES')
		print(math.pi * h * d * d / (4 * v - e * math.pi * d * d))
main()


import sys
import math
input = sys.stdin.readline

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

def print_array(arr):
	print_array(' '.join(map(str, arr)))
(d, h, v, e) = multi_input()
initial = math.pi * d * d * h / 4
area = math.pi * d * d / 4
e = area * e
if e >= v:
	print('NO')
else:
	t = initial / (v - e)
	print('YES\n{0:.12f}'.format(t))


from math import pi
(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
volume_1 = pi * (d / 2) ** 2 * h
volume_per_second = pi * (d / 2) ** 2 * e
measure = v - volume_per_second
if measure > 0:
	print('YES', volume_1 / measure, sep='\n')
else:
	print('NO')


import os
import sys
from io import BytesIO, IOBase
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
from math import ceil, floor, sqrt, log2, gcd, pi
from heapq import heappush, heappop
from bisect import bisect_left, bisect
import sys
abc = 'abcdefghijklmnopqrstuvwxyz'
ABC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
(d, h, v, e) = map(int, input().split())
e_ = pi * d * d / 4
e__ = v / e_
if e__ <= e:
	print('NO')
else:
	print('YES')
	print(h / (e__ - e))


import math
x = input()
x = x.split()
(d, h, v, e) = (int(x[0]), int(x[1]), int(x[2]), int(x[3]))
left = math.pi * d * d / 4
denom = 4 * v / (math.pi * d * d) - e
if denom > 0:
	print('YES')
	print(h / denom)
else:
	print('NO')


import math
pi = math.pi
(d, h, v, e) = input().split(' ')
d = int(d)
h = int(h)
v = int(v)
e = int(e)
area = d ** 2 / 4 * pi
decrease = v / area
if decrease > e:
	print('YES\n' + str(h / (decrease - e)))
else:
	print('NO')


import math
inp = input()
arr = inp.split()
d = int(arr[0])
h = int(arr[1])
v = float(arr[2])
e = float(arr[3])
decreasingVelocity = v / float(math.pi * d ** 2 / 4)
increasingVelocity = e
if increasingVelocity >= decreasingVelocity:
	print('NO')
else:
	print('YES\n' + str(h / (decreasingVelocity - increasingVelocity)))


from sys import stdin, stdout
import sys
INF = 100000000000.0
import math

def get_int():
	return int(stdin.readline().strip())

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

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

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

def op(c):
	return stdout.write(c)
from collections import defaultdict
(d, h, v, e) = get_ints()
r1 = 4 * v / (math.pi * d * d)
t = h / (r1 - e)
if t > 0:
	print('YES')
	print('%.12f' % t)
else:
	print('NO')


(d, h, v, e) = map(float, input().split(' '))
PI = 3.14159265
incUp = PI * d * d / 4 * e
cur = PI * d * d / 4 * h
if incUp >= v:
	print('NO')
else:
	print('YES\n', cur / (v - incUp))


import sys
import os
import math
from sys import stdin, stderr, stdout, exit
(d, h, v, e) = list(map(int, stdin.readline().split()))
v = 4 * v / math.pi / d / d
if v < e:
	stdout.write('NO')
	exit(0)
stdout.write('YES\n')
stdout.write(str(h / (v - e)))


(d, h, v, e) = map(int, input().split())
if int(v) * 10 ** (-6) < int(e) / 100 * 3.141592 * (int(d) / 200) ** 2:
	print('NO')
else:
	print('YES')
	t = int(h) / 100 * 3.141592 * (int(d) / 200) ** 2 / (int(v) * 10 ** (-6) - int(e) / 100 * 3.141592 * (int(d) / 200) ** 2)
	print(t)


import math
(d, h, v, e) = map(float, input().split())
a = math.pi * (d * d)
a /= 4
if float(float(v) / a) <= e:
	print('NO')
else:
	print('YES')
	t1 = v / a - e
	t1 = h / t1
	print(t1)


import math
pi = math.pi
inp = input().split()
(d, h, v, e) = (int(inp[0]), int(inp[1]), int(inp[2]), int(inp[3]))
s = d * d * pi / 4
r = s * e
if v <= r:
	print('NO')
else:
	ans = s * h / (v - r)
	print('YES\n', ans, sep='')


import math
(d, h, v, e) = [int(x) for x in input().split()]
speed_inc = math.pi * (d / 2 * (d / 2)) * e
speed_drink = v
if v > speed_inc:
	print('YES')
	print(math.pi * (d / 2) ** 2 * h / (v - speed_inc))
else:
	print('NO')


import math
(d, h, drink_v, e) = map(int, input().strip().split())
rain_v = math.pi * (d / 2) ** 2 * e
if rain_v >= drink_v:
	print('NO')
else:
	print('YES')
	print(math.pi * (d / 2) ** 2 * h / (drink_v - rain_v))


from math import pi
(d, h, v, e) = map(int, input().split())
cmvol = pi * (d / 2) ** 2
init = h * cmvol
decr = v
incr = e * cmvol
if incr - decr >= 1e-09:
	print('NO')
else:
	print('YES')
	print(init / (decr - incr))


import math

def first():
	inp = input().split(' ')
	d = float(inp[0])
	h = float(inp[1])
	v = float(inp[2])
	e = float(inp[3])
	h_y = v / (math.pi * (d / 2) ** 2)
	if h_y > e:
		print('YES')
		print(h / (h_y - e))
	else:
		print('NO')
first()


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
volume = pi * r ** 2 * h
cnt = 0
fill = e * pi * r ** 2
if v < fill:
	print('NO')
	exit()
print('YES')
volume = pi * r ** 2 * h
up = fill - v
print(abs(volume / up))


from __future__ import division
from math import pi

def rlist(t):
	return map(t, input().split())

def read_int_list():
	return rlist(int)

def write_list(lst, divider=' '):
	print(divider.join(map(str, lst)))

def main():
	(d, h, v, e) = read_int_list()
	try:
		ans = h / (4 * v / pi / d ** 2 - e)
	except ZeroDivisionError:
		return print('NO')
	print('NO' if ans < 0 else 'YES\n{}'.format(ans))
main()


import sys
import math
import itertools as it
import operator as op
import fractions as fr
(d, h, v, e) = map(int, sys.stdin.readline().split())
s = math.pi * d * d / 4
v /= s
if v <= e:
	print('NO')
else:
	print('YES')
	print(h / (v - e))


import math

def main():
	(d, h, v, e) = (int(x) for x in input().split())
	(success, time) = solver(d, h, v, e)
	print(success)
	if success == 'YES':
		print(time)

def solver(d, h, v, e):
	growthRate = e * (d / 2) ** 2 * math.pi
	if growthRate > v:
		return ('NO', None)
	else:
		volume = h * (d / 2) ** 2 * math.pi
		return ('YES', volume / (v - growthRate))
main()


import math
pi = math.acos(-1.0)
[d, h, v, e] = list(map(int, input().split()))
t = pi * (d * 0.5) ** 2 * h / (v - pi * (d * 0.5) ** 2 * e)
if t < 0:
	print('NO')
else:
	print('YES')
	print(t)


import math
str = input('').split(' ')
d = int(str[0])
h = int(str[1])
v = int(str[2])
e = int(str[3])
tmp = d * d / 4 * math.pi
if tmp * e < v:
	print('YES')
	print(tmp * h / (v - tmp * e))
else:
	print('NO')


import math
tab = [float(i) for i in input().split()]
d = tab[0]
h = tab[1]
v = tab[2]
e = tab[3]
he = 4 * v / (math.pi * d ** 2)
if e >= he:
	print('NO')
else:
	t = h / (he - e)
	print('YES')
	print(t)


(d, h, v, e) = map(float, input().split())
pi = 3.141592653589793
if pi * d * d * e / 4 >= v:
	print('NO')
else:
	print('YES')
	ans = pi * d * d * h / 4
	ans = ans / (v - pi * d * d * e / 4)
	print(ans)


p = 3.14159265959
a = input()
l = a.split(' ')
l1 = []
for i in l:
	l1.append(int(i))
d = l1[0]
h = l1[1]
v = l1[2]
e = l1[3]
increase = p * d ** 2 / 4 * e
if increase > v:
	print('NO')
else:
	t = p * d ** 2 * h / 4 / (v - p * d ** 2 * e / 4)
	print('YES')
	print(t)


(d, h, v, e) = map(int, input().split())
pi = 3.14159265358979
t = -h / (e - v / (pi * (d / 2) * (d / 2)))
if t < 0:
	print('NO')
else:
	print('YES')
	print(t)


from math import *
(d, h, v, e) = map(int, input().split())
dh = v * 4 / pi / d / d
if e >= dh or h > (dh - e) * 10000:
	print('NO')
else:
	print('YES', h / (dh - e), sep='\n')


import math
(d, h, v, e) = map(int, input().split())
eps = 10 ** (-4)
l = -1
r = 10 ** 4
res = -1

def space(t):
	return math.pi * (d * d) / 4 * (h + e * t) - v * t
if e * math.pi * (d * d) / 4 > v:
	print('NO')
else:
	while abs(space(res)) >= eps:
		res = (l + r) / 2
		if space(res) < 0:
			r = res
		else:
			l = res
	print('YES')
	print(res)


import math

def yesorno(d, h, v, e):
	h_speed = -v / (math.pi * (d / 2) ** 2)
	h0 = h
	for t in range(1, 10 ** 4 + 1):
		h = h + h_speed + e
		if h <= 0:
			time = -h0 / (e + h_speed)
			print('YES')
			return time
	return 'NO'
(d, h, v, e) = map(int, input().split())
print(yesorno(d, h, v, e))


from math import pi
(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
r = d / 2
S = pi * r ** 2
E1 = v / S
deltaH = E1 - e
if E1 - e <= 1e-10:
	print('NO')
else:
	print('YES')
	print(h / deltaH)


import math
try:
	while True:
		(d, h, v, e) = map(int, input().split())
		v /= math.pi * (d * 0.5) ** 2
		if e >= v:
			print('NO')
		else:
			print('YES')
			print(h / (v - e))
except EOFError:
	pass


from math import pi
(d, h, v, e) = map(int, input().split())
ans = d * d / 4 * pi * h / (v - d * d / 4 * pi * e)
print(['NO', 'YES\n%f' % ans][ans > 0])


__author__ = 'Andrey'
import math
(d, h, v, e) = map(float, input().split())
s = math.pi * (d / 2) ** 2
out = v / s
if e >= out:
	print('NO')
else:
	change = out - e
	print('YES')
	print(h / change)


from math import pi
(d, h, v, e) = list(map(int, input().split()))
r = d / 2
hr = v / (pi * r * r)
if hr > e:
	print('YES')
	ans = h / (hr - e)
	print(ans)
else:
	print('NO')


import math
(d, h, v, e) = [int(i) for i in input().split()]
t = e * d ** 2 * math.pi / 4
if t >= v:
	print('NO')
else:
	print('YES')
	print(d ** 2 * math.pi / 4 * h / (v - t))


PI = 3.1415926535
(d, h, v, e) = [int(i) for i in input().split()]
ans = PI * d * d * h / (4 * v - PI * d * d * e)
print('NO' if ans < 0 else 'YES\n' + '{0:.10f}'.format(ans))


lst = input().split()
intlst = list(map(int, lst))
d = intlst[0]
h = intlst[1]
v = intlst[2]
e = intlst[3]
if 3.1415926535 * d * d * e / 4 > v:
	print('NO')
else:
	print('YES')
	t = 3.14159265359 * d * d * h / 4 / (v - 3.14159265359 * d * d * e / 4)
	print(t)


import math
(d, h, v_dec, e) = map(int, input().split())
area = d * d / 4 * math.pi
volume = area * h
v_inc = area * e
if v_inc > v_dec:
	print('NO')
else:
	print('YES')
	print(volume / (v_dec - v_inc))


(d, h, v, e) = map(int, input().split())
p = 3.1415926
x = d / 2 * (d / 2)
u = e * p * (d / 2) * (d / 2)
if u >= v:
	print('NO')
else:
	h = p * x * h
	print('YES')
	print(h / (v - u))


from math import *
(d, h, v, e) = (int(z) for z in input().split())
v = v / (acos(-1) * d * d / 4)
if v - e <= 0:
	print('NO')
else:
	print('YES')
	print(h / (v - e))


(d, h, v, e) = input().split()
(d, h, v, e) = (int(d), int(h), int(v), int(e))
PI = 3.14159265359
r = d / 2
decrease = v / (PI * r * r)
diff = decrease - e
if diff <= 0:
	print('NO')
else:
	res = h / diff
	if res > 10000:
		print('NO')
	else:
		print('YES')
		print(h / diff)


(d, h, v, e) = [int(i) for i in input().split()]
p = 3.1415926535
v_0 = p * h * (d ** 2 / 4)
v_drink = v
v_rain = e * (d ** 2 / 4) * p
if v_rain > v_drink:
	print('NO')
else:
	l = 0
	r = 10 ** 4 + 5
	d = 10 ** 10
	while l * d + 1 < r * d:
		m = (l + r) / 2
		box = v_0 - (v_drink - v_rain) * m
		if box < 0:
			r = m
		else:
			l = m
	print('YES')
	print(l)


import math
import cmath
pi = math.acos(-1)
(d, h, v, e) = map(float, input().split())
r = v / (pi * (d / 2) ** 2)
if r > e:
	print('YES')
	print(h / (r - e))
else:
	print('NO')


import math
(d, h, v, e) = map(int, input().split())
area = math.pi * d * d / 4
if area * e > v:
	print('NO')
	exit()
t = area * h / (v - area * e)
print('YES')
print(t)


from math import pi
(d, h, v, e) = map(int, input().split())
x = 4 * v / (pi * d * d)
if x <= e:
	print('NO')
else:
	print('YES')
	t = h / (x - e)
	print(t)


from math import pi

def empty(r, h, v, e):
	ve = v / (pi * r * r)
	return ['NO'] if ve <= e else ['YES', h / (ve - e)]
(d, h, v, e) = list(map(int, input().split()))
[print(r) for r in empty(d / 2, h, v, e)]


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
if pi * r ** 2 * e > v:
	print('NO')
else:
	print('YES')
	base = pi * r ** 2 * h
	base2 = pi * r ** 2 * e - v
	print(abs(base / base2))


import math
x = list(map(int, input().split(' ')))
d = x[0]
h = x[1]
volc = x[2]
e = x[3]
result = volc * 4 / (3.1415926 * d * d)
if result < e:
	print('NO')
else:
	print('YES')
	print(h / (result - e))


import math
(d, h, v, e) = map(float, input().split(' '))
increaseRate = math.pi * d * d / 4 * e
curWater = math.pi * d * d / 4 * h
if increaseRate >= v:
	print('NO')
else:
	print('YES\n', curWater / (v - increaseRate))


import math
(d, h, v, e) = [int(i) for i in input().split()]
V = h * d * d * math.pi / 4
e = e * d * d * math.pi / 4
if v - e <= 0:
	print('NO')
else:
	t = V / (v - e)
	print('YES', t, sep='\n')


from math import pi
(d, h, v, e) = map(int, input().split())
r = d / 2
area = pi * r * r
relative_growth = e - v / area
if relative_growth >= 0.0:
	print('NO')
	exit(0)
sol = abs(h / relative_growth)
print('YES\n%.15f' % sol)


import math
from sys import stdin, stdout
(d, h, v, e) = [int(x) for x in stdin.readline().strip().split()]
volume_1cm = math.pi * d * d / 4
speed = v / volume_1cm
if e > speed:
	stdout.write('NO')
else:
	stdout.write('YES' + '\n')
	stdout.write(str(h / (speed - e)) + '\n')


import math
inp = list(map(float, input().split()))
d = inp[0]
h = inp[1]
v = inp[2]
e = inp[3]
if 4 * v / (math.pi * d * d) > e:
	print('YES')
	print(h / (4 * v / (math.pi * d * d) - e))
else:
	print('NO')


(d, h, v, e) = [int(i) for i in input().split()]
A = 3.141592653589793 * (d / 2.0) ** 2
drinking = v / A
if e >= drinking:
	print('NO')
else:
	print('YES')
	print(-h / (e - drinking))


import math
(d, h, v, e) = map(int, input().split())
if e > v:
	exit(print('NO'))
ans = h / (v / (math.pi * (d / 2) ** 2) - e)
print('NO' if ans < 0 else 'YES\n' + str(ans))


(d, h, v, e) = map(float, input().split())
pi = 3.141592653589
increase = e * (d / 2) ** 2
if v / pi <= increase:
	print('NO')
else:
	print('YES')
	print(h * (d / 2) ** 2 / (v / pi - increase))


(d, h, v, e) = map(int, input().split())
radius = d / 2
PI = 3.1415926535897
e *= PI * radius * radius
if e >= v:
	print('NO')
else:
	rate = v - e
	volume = h * PI * radius * radius
	print('YES')
	print(volume / rate)


import math
string = input()
p = string.split(' ')
d = float(p[0])
h = float(p[1])
v = float(p[2])
e = float(p[3])
S = (d / 2) ** 2 * math.pi
x = v / S
if x < e:
	print('NO')
else:
	print('YES')
	vUbiv = x - e
	t = h / vUbiv
	print(t)


from math import pi

def solve(d, h, s1, s2):
	r = d / 2
	a = pi * r ** 2 * h
	t = a / (s1 - s2 * pi * r ** 2)
	if t < 0 or t > 10 ** 4:
		print('NO')
		return
	print('YES')
	print(t)

def main():
	arr = list(map(int, list(input().split(' '))))
	solve(*arr)
main()


from math import pi
(d, h, v, e) = list(map(int, input().split()))
H = 4 * v / (pi * d ** 2)
if H <= e:
	print('NO')
else:
	ans = h / (H - e)
	print('YES')
	print(ans)


import math
con = 0
for i in input().strip().split(' '):
	if con == 0:
		d = float(i)
	elif con == 1:
		h = float(i)
	elif con == 2:
		v = float(i)
	else:
		e = float(i)
	con = con + 1
t = -math.pi * d * d * h / 4
a = e * math.pi * d * d / 4
a -= v
if a >= 0:
	print('NO')
	exit()
t /= a
print('YES')
print(t)


(d, h, v, e) = map(int, input().split(' '))
PI = 3.1415926
S = d / 2 * (d / 2) * PI
V = h * S
V2 = e * S
if V2 >= v:
	print('NO')
	exit
else:
	print('YES')
	print(abs(V / (V2 - v)))


from math import pi
(d, h, u, e) = map(int, input().split(' '))
u = 4 * u / (pi * d * d)
if e >= u:
	print('NO')
else:
	print('YES')
	print(h / (u - e))


(D, H, V, E) = input().split()
D = float(D)
H = float(H)
V = float(V)
E = float(E)
D = D / 2
from math import pi
if pi * D * D * E >= V:
	print('NO')
else:
	print('YES')
	print(pi * D * D * H / (V - pi * D * D * E))