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
					                                import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
				 
				 
				 
				 
				 
				 public class Solution2 implements Runnable
				{
				    static final long MAX = 464897L;
				    static class InputReader
				    {
				        private InputStream stream;
				        private byte[] buf = new byte[1024];
				        private int curChar;
				        private int numChars;
				        private SpaceCharFilter filter;
				        private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
				 
				        public InputReader(InputStream stream)
				        {
				            this.stream = stream;
				        }
				        
				        public int read()
				        {
				            if (numChars==-1) 
				                throw new InputMismatchException();
				            
				            if (curChar >= numChars)
				            {
				                curChar = 0;
				                try 
				                {
				                    numChars = stream.read(buf);
				                }
				                catch (IOException e)
				                {
				                    throw new InputMismatchException();
				                }
				                
				                if(numChars <= 0)                
				                    return -1;
				            }
				            return buf[curChar++];
				        }
				     
				        public String nextLine()
				        {
				            String str = "";
				            try
				            {
				                str = br.readLine();
				            }
				            catch (IOException e)
				            {
				                e.printStackTrace();
				            }
				            return str;
				        }
				        public int nextInt()
				        {
				            int c = read();
				            
				            while(isSpaceChar(c)) 
				                c = read();
				            
				            int sgn = 1;
				            
				            if (c == '-') 
				            {
				                sgn = -1;
				                c = read();
				            }
				            
				            int res = 0;
				            do 
				            {
				                if(c<'0'||c>'9') 
				                    throw new InputMismatchException();
				                res *= 10;
				                res += c - '0';
				                c = read();
				            }
				            while (!isSpaceChar(c)); 
				            
				            return res * sgn;
				        }
				        
				        public long nextLong() 
				        {
				            int c = read();
				            while (isSpaceChar(c))
				                c = read();
				            int sgn = 1;
				            if (c == '-') 
				            {
				                sgn = -1;
				                c = read();
				            }
				            long res = 0;
				            
				            do 
				            {
				                if (c < '0' || c > '9')
				                    throw new InputMismatchException();
				                res *= 10;
				                res += c - '0';
				                c = read();
				            }
				            while (!isSpaceChar(c));
				                return res * sgn;
				        }
				        
				        public double nextDouble() 
				        {
				            int c = read();
				            while (isSpaceChar(c))
				                c = read();
				            int sgn = 1;
				            if (c == '-') 
				            {
				                sgn = -1;
				                c = read();
				            }
				            double res = 0;
				            while (!isSpaceChar(c) && c != '.') 
				            {
				                if (c == 'e' || c == 'E')
				                    return res * Math.pow(10, nextInt());
				                if (c < '0' || c > '9')
				                    throw new InputMismatchException();
				                res *= 10;
				                res += c - '0';
				                c = read();
				            }
				            if (c == '.') 
				            {
				                c = read();
				                double m = 1;
				                while (!isSpaceChar(c)) 
				                {
				                    if (c == 'e' || c == 'E')
				                        return res * Math.pow(10, nextInt());
				                    if (c < '0' || c > '9')
				                        throw new InputMismatchException();
				                    m /= 10;
				                    res += (c - '0') * m;
				                    c = read();
				                }
				            }
				            return res * sgn;
				        }
				        
				        public String readString() 
				        {
				            int c = read();
				            while (isSpaceChar(c))
				                c = read();
				            StringBuilder res = new StringBuilder();
				            do 
				            {
				                res.appendCodePoint(c);
				                c = read();
				            } 
				            while (!isSpaceChar(c));
				            
				            return res.toString();
				        }
				     
				        public boolean isSpaceChar(int c) 
				        {
				            if (filter != null)
				                return filter.isSpaceChar(c);
				            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				        }
				     
				        public String next() 
				        {
				            return readString();
				        }
				        
				        public interface SpaceCharFilter 
				        {
				            public boolean isSpaceChar(int ch);
				        }
				    }
				     
				    public static void main(String args[]) throws Exception
				    {
				        new Thread(null, new Solution2(),"Solution2",1<<26).start();
				    }   
				    static long gcd(long a, long b) 
				    { 
				      if (b == 0) 
				        return a; 
				      return gcd(b, a % b);  
				    } 
				    static long lcm(long a,long b) {
				    	return (a*b)/gcd(a,b);
				    }
				    int maxn = 100005;
				    long MOD = 1000000007;
				    long prime = 29;
				    ArrayList<Integer> adj[];
				    
				    public void run() 
				    {
				    	InputReader sc = new InputReader(System.in);
						PrintWriter w = new PrintWriter(System.out);
						int t = sc.nextInt();
						while(t-- > 0) {
							int d = sc.nextInt();
							double dis = d*d - 4*d;
							if(dis < 0) {
								System.out.println("N");
								continue;
							}
							System.out.print("Y ");
							dis = Math.sqrt(dis);
							
							double one = (d + dis)/2;
							double two = d - one;
							System.out.printf("%.10f ",one);
							System.out.printf("%.10f ",two);
							System.out.println();
						}
						w.close();
				    }
				    
				    int sieveOfEratosthenes(int n,long num) 
				    { 
				        // Create a boolean array "prime[0..n]" and initialize 
				        // all entries it as true. A value in prime[i] will 
				        // finally be false if i is Not a prime, else true. 
				        boolean prime[] = new boolean[n+1]; 
				        for(int i=0;i<n;i++) 
				            prime[i] = true; 
				          
				        for(int p = 2; p*p <=n; p++) 
				        { 
				            // If prime[p] is not changed, then it is a prime 
				            if(prime[p] == true) 
				            { 
				                // Update all multiples of p 
				                for(int i = p*2; i <= n; i += p) 
				                    prime[i] = false; 
				            } 
				        } 
				          
				        // Print all prime numbers 
				        for(int i = 2; i <= n; i++) 
				        { 
				            if(prime[i] == true) {
				            	if(num % i == 0) {
				            		return i;
				            	}
				            }
				            	
				        } 
				        return -1;
				    } 
				    static boolean isPrime(long n) 
				    { 
				        // Corner cases 
				        if (n <= 1) return false; 
				        if (n <= 3) return true; 
				      
				        // This is checked so that we can skip  
				        // middle five numbers in below loop 
				        if (n % 2 == 0 || n % 3 == 0) return false; 
				      
				        for (long i = 5; i * i <= n; i = i + 6) 
				            if (n % i == 0 || n % (i + 2) == 0) 
				            return false; 
				      
				        return true; 
				    } 
				    long[] fact = new long[100005];	
				    long nCr(int n,int r){ 
				    	long tmp1 = (fact[r] * fact[n-r]) % MOD;
				    	tmp1 = power(tmp1,MOD-2,MOD);
				    	long tmp2 = (fact[n] * tmp1) % MOD;
				    	return tmp2;
	 			    }
				    static long power(long a,long b,long mod) {
						long ans = 1;
						a = a % mod;
						while(b != 0) {
							if(b % 2 == 1) {
								ans = (ans * a) % mod;
							}
							a = (a * a) % mod;
							b = b/2;
						}
						return ans;
					}
				   void pre() {
					   fact[0] = 1;
					   for(int i = 1;i < 100005;i++) {
						   fact[i] = (fact[i-1] * i) % MOD;
					   }
				   }
				    class Pair implements Comparable<Pair>{
				        long a;
				        long b;
				        long c;
				        Pair(long a,long b,long c){
				            this.b = b;
				            this.a = a;
				            this.c = c;
				        }
				        public boolean equals(Object o) {
				            Pair p = (Pair)o;
				            return this.a == p.a && this.b == this.b;
				        }
				        public int hashCode(){
				            return Long.hashCode(a)*27 + Long.hashCode(b)*31;
				        }
				        public int compareTo(Pair p) {
				            return Long.compare(p.a,this.a);
				        }
				    }
				    
				}
