Problem: Try guessing the statement from this picture: 

<image>

You are given a non-negative integer d. You have to find two non-negative real numbers a and b such that a + b = d and a ⋅ b = d.

Input

The first line contains t (1 ≤ t ≤ 10^3) — the number of test cases.

Each test case contains one integer d (0 ≤ d ≤ 10^3).

Output

For each test print one line.

If there is an answer for the i-th test, print "Y", and then the numbers a and b.

If there is no answer for the i-th test, print "N".

Your answer will be considered correct if |(a + b) - a ⋅ b| ≤ 10^{-6} and |(a + b) - d| ≤ 10^{-6}.

Example

Input


7
69
0
1
4
5
999
1000


Output


Y 67.985071301 1.014928699
Y 0.000000000 0.000000000
N
Y 2.000000000 2.000000000
Y 3.618033989 1.381966011
Y 997.998996990 1.001003010
Y 998.998997995 1.001002005

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class C {
	IO io = new IO();
	
	void begin() {
		int jcase = io.nextInt();
		for(int icase=0; icase<jcase; icase++) {
			double n = io.nextDouble();
			if(n*n - 4*n < 0) {
				io.out("N\n");
			}
			else {
				double det = Math.sqrt(n*n - 4*n);
				double a = 0.5 * (n + det);
				double b = 0.5 * (n - det);
				io.out("Y %.9f %.9f\n", a, b);
			}
		}
		io.done();
	}
	
	public static void main(String[] args) {
		(new C()).begin();
	}
	
	static class IO {
		BufferedReader reader;
		StringTokenizer tokenizer;
		BufferedWriter writer;
		boolean isAutoFlush;
		
		public IO() {
			this(false, null, null);
		}
		
		public IO(boolean isAutoFlush, String fileFrom, String fileTo) {
			if(fileFrom == null) {
				reader = new BufferedReader(new InputStreamReader(System.in));
			} else {
				try {
					reader = new BufferedReader(new FileReader(new File(fileFrom)));
				} catch(IOException e) {
					throw new RuntimeException(e);
				}
			}
			
			if(fileTo == null) {
				writer = new BufferedWriter(new OutputStreamWriter(System.out));
			} else {
				try {
					writer = new BufferedWriter(new FileWriter(new File(fileTo)));
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			
			tokenizer = new StringTokenizer("");
		}
		
		private String next() {
			while (!tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) { //EOF
					e.printStackTrace();
				}
			}
			return tokenizer.nextToken();
		}
		
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public String nextString() {
			return next();
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		
		public void out(String format, Object... args) {
			try {
				String string = String.format(format, args);
				writer.write(string);
				if(isAutoFlush) writer.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		public void done() {
			try {
				writer.flush();
				reader.close();
				writer.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}