Problem: 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.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class KSN {

	// static final File inFile = new File("a.in");
	// static final File outFile = new File("a.out");

	static PrintWriter out;

	static void input() throws IOException {
		Reader.Sys_init(System.in);
		Reader.delimiter = " ";
	}

	public static void main(String[] args) throws IOException {

		out = new PrintWriter(System.out);
		input();
		solve();

	}

	static int M, C, price[][] = new int[25][25];
	// price[g (<= 20)][model (<= 20)]
	static int memo[][] = new int[210][25];

	static void solve() throws IOException {

		/*
		 * // easy to code if you are already familiar with it int i, j, TC,
		 * score; TC = Reader.nextInt(); while (TC-- > 0) { M =
		 * Reader.nextInt(); C = Reader.nextInt(); for (i = 0; i < C; i++) {
		 * price[i][0] = Reader.nextInt(); // store K in price[i][0] for (j = 1;
		 * j <= price[i][0]; j++) price[i][j] = Reader.nextInt(); }
		 * 
		 * //initializing to -1 for(int x = 0; x < 25 ; ++x) for(int y = 0 ;
		 * y<25; ++y ) memo[x][y] = -1;
		 * 
		 * 
		 * // TOP-DOWN: initialize DP memo table score = shop(M, 0); // start
		 * the top-down DP if (score < 0) out.println("no solution\n"); else
		 * out.print(score); } // TOP-DOWN: memoize ans and return it
		 */
		boolean not = false;
		float ans = 0;
		int d = Reader.nextInt();
		int h = Reader.nextInt();
		int v = Reader.nextInt();
		int e = Reader.nextInt();

		float base_area = ((float) Math.PI * (d * d) / 4);
		float dissi_h = v / (base_area);

		if (dissi_h <= e)
			not = true;

		else {

			ans = -(h) / (e - dissi_h);
		}

		if (not)
			out.println("NO");
		else {
			out.println("YES");
			out.println(ans);
		}

		out.flush();
		out.close();

	}

	// TOP-DOWN: dp table memo[money (<= 200)][g (<= 20)]
	static int shop(int money, int g) {
		if (money < 0)
			return -1000000000;
		// fail, return a large -ve number
		if (g == C)
			return M - money;
		// we have bought last garment, done
		// if the line below is commented, top-down DP will become
		// backtracking!!
		if (memo[money][g] != -1)
			return memo[money][g]; // TOP-DOWN: memoization
		int ans = -1;
		// start with a -ve number as all prices are non negative
		for (int model = 1; model <= price[g][0]; model++)
			// try all models
			ans = Math.max(ans, shop(money - price[g][model], g + 1));
		return memo[money][g] = ans;
	}

	static class Reader {

		static BufferedReader reader;
		static StringTokenizer tokenizer;
		static String delimiter = " ";

		static void Sys_init(InputStream input) throws IOException {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer(reader.readLine());
		}

		static void File_init(File input) throws FileNotFoundException {
			reader = new BufferedReader(new FileReader(input));
			tokenizer = new StringTokenizer(" ");
		}

		static String next() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {

				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken(delimiter);
		}

		static String nextLine() throws IOException {
			return reader.readLine();
		}

		static char nextChar() throws IOException {
			return (char) reader.read();
		}

		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		static double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		static long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}

			return arr;
		}

		static int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

	}

}