Problem: You are given one integer number n. Find three distinct integers a, b, c such that 2 ≤ a, b, c and a ⋅ b ⋅ c = n or say that it is impossible to do it.

If there are several answers, you can print any.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.

The next n lines describe test cases. The i-th test case is given on a new line as one integer n (2 ≤ n ≤ 10^9).

Output

For each test case, print the answer on it. Print "NO" if it is impossible to represent n as a ⋅ b ⋅ c for some distinct integers a, b, c such that 2 ≤ a, b, c.

Otherwise, print "YES" and any possible such representation.

Example

Input


5
64
32
97
2
12345


Output


YES
2 4 8 
NO
NO
NO
YES
3 5 823 

Solution (in JAVA):

Solution:
import java.util.* ;
import java.math.*;
import java.io.*;
 
 
public class javaTemplate {
	
// 	 public static final int M = 1000000007 ;
    public static final int M = 1000003 ;
	static FastReader sc = new FastReader();
	//	static Scanner sc = new Scanner(System.in) ;
	
	public static void main(String[] args) {
		
		
 
int t= sc.nextInt() ;
		while(t -- != 0) {
			int n = sc.nextInt() ;
			int a = n , b = n , c = n ;
			
			for(int i = 2 ; i*i <= n ; i++) {
				if(n % i == 0) {
					a = i ;
					break ;
				}
			}
			
			n = n/a ;
			
			for(int i = 2; i*i <= n ; i++) {
				if(n%i == 0) {
					if(i != a) {
						b = Math.min(b, i) ;
						break ;
					} else {
						if((n/i) != i && (n/i) != a) {
							b = Math.min(b,(n/i)) ;
						}
					}
				}
			}
			
			c = n/b ;
			
			if(a!= b && b!= c && c != a && c >= 2) {
				System.out.println("YES");
				System.out.println(a + " " + b + " " + c);
			} else {
				System.out.println("NO");
			}
		}
 
 
		
		
	}
	
 
	
 
 
    
    
    
    
    
	
 
 
	
	
//_________________________//Template//_____________________________________________________________________
	
	
		//		FAST I/O
		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;
	        
	        public FastReader()
	        {
	            br = new BufferedReader(
	                new InputStreamReader(System.in));
	        }
	 
	        String next()
	        {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	 
	        long nextLong() { return Long.parseLong(next()); }
	 
	        double nextDouble()
	        {
	            return Double.parseDouble(next());
	        }
	 
	        String nextLine()
	        {
	            String str = "";
	            try {
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
		}
	
	
		
		
//		Check Perfect Squre
		public static boolean checkPerfectSquare(double number) {   
			
			double sqrt=Math.sqrt(number);   
		
			return ((sqrt - Math.floor(sqrt)) == 0);   
		}   
		
		
		
		
		
	static boolean isPrime(int n) {
	        
	        if (n <= 1) return false;
	  
	        for (int i = 2; i < n; i++) {
	            if (n % i == 0) return false;
	        	}
	  
	        return true;
	    }
		
		
		
		
		// Modulo
		static int mod(int a)
		{
		    return (a%M + M) % M;
		}
		
		
		
		
		
			
			
		
		
		
		//		Palindrom or Not
		static boolean isPalindrome(StringBuilder str, int low, int high) {
					
					while (low < high) {
						if (str.charAt(low) != str.charAt(high)) return false;
					 	low++;
					 	high--;
					}
					return true;
				}
	
	
		// Euler Tortient fx
	static int Phi(int n) {
		
		int count = 0 ;
		for(int i = 1 ; i< n ; i++) {
			if(GCD(i,n) == 1) count ++ ;
		}
		return count ;
	}
	
	
	
		// Integer Sort
		static void sort(int[] a) 
		   {
				ArrayList<Integer> l=new ArrayList<>();
				for (int i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
		
		
		
		// Long Sort
		static void sort(long[] a) 
		   {
				ArrayList<Long> l=new ArrayList<>();
				for (long i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
	
		
		// boolean Value
		static void value(boolean val)
	    {
	       System.out.println(val ? "YES" : "NO");
	       System.out.flush();
	    }
	
	
		
	
		// GCD
		public static long GCD(long a , long b) {
				if(b == 0) return a ;
				
				return GCD(b, a%b) ;
			}
	
		
		
		
		
		
		// sieve
		public static boolean [] sieveofEratosthenes(int n) {
			
			boolean isPrime[] = new boolean[n+1] ;
			Arrays.fill(isPrime, true);
			isPrime[0] = false ;
			isPrime[1] = false ;
			
			for(int i = 2 ; i * i <= n ; i++) {
				
				for(int j = 2 * i ; j<= n ; j+= i) {
					isPrime[j] = false ;
				}
			}
			
			return isPrime ;
		}
		
		
		
		
		// fastPower
		public static long fastPowerModulo(long a, long b, long n) {
			
			long res = 1 ;
			
			while(b > 0) {
			if((b&1) != 0) {
				res = (res * a % n) % n ;
			}
			
			a = (a % n * a % n) % n ;
			b = b >> 1 ;
			}
			
			return res ;
		}
		
		
		
		
		// check if sorted or not	
		public static boolean isSorted(int[] a)
	    {
	        for (int i = 0; i < a.length - 1; i++)
	        {
	            if (a[i] > a[i + 1]) {
	                return false;
	            }
	        }
	 
	        return true;
	    }
	
	
			//		Palindrom or Not
		static boolean isPalindrome(String str, int low, int high) {
					
					while (low < high) {
						if (str.charAt(low) != str.charAt(high)) return false;
					 	low++;
					 	high--;
					}
					return true;
				}
		
		
		
    
	
 
}