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.io.*;
import java.util.*;
import java.lang.*;
// A U T H O R : s a n 1 d h y a
 
public class cf1294C {
	static long Mod1 = 1000000007;
 
	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 ni() {
			return Integer.parseInt(next());
		}
 
		long nl() {
			return Long.parseLong(next());
		}
 
		double nd() {
			return Double.parseDouble(next());
		}
 
		String nln() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}
 
	/*
	 * public static void sortbyColumn(int arr[][], int col) { // Using built-in
	 * sort function Arrays.sort Arrays.sort(arr, new Comparator<int[]>() {
	 * 
	 * @Override // Compare values according to columns public int compare(final
	 * int[] entry1, final int[] entry2) {
	 * 
	 * // To sort in descending order revert // the '>' Operator if (entry1[col] >
	 * entry2[col]) return 1; else return -1; } }); // End of function call sort().
	 * }
	 */
/*	public static long modex(long x, long y) {
		x = x % Mod1;
		long ret = 1;
		while (y > 0) {
			if (y % 2 != 0) {
				ret = ret * x % Mod1;
			}
			x = x * x % Mod1;
			y >>= 1;
		}
		return ret;
	}
*/
/*	public static long mplr(long x, long y) {
		long ret = 0;
		while (y != 0) {
			if (y % 2 != 0) {
				ret = (ret + x) % Mod1;
			}
			x = (x + x) % Mod1;
			y >>= 1;
		}
		return ret;
	}
*/
	public static void main(String[] args) {
		FastReader sc = new FastReader();
	    int  t=sc.ni();
	    while(t-->0) {
	    	long n=sc.nl();
	    	long q=n;
	    //	long sq=(long)Math.ceil(Math.sqrt((double)n));
	    	long a[]=new long[2];
	    	int c=0; int f=0;
	    	for(long i=2;i<(long)Math.sqrt(q);i++) {
	    		if(n%i==0)
	    			{
	    			a[c++]=i;
	    			n=n/i;
	    			}
	    		if(c==2)
	    			{
	    			f=1;
	    			break;
	    			}
	    	}
	    	if(f==0)
	    		System.out.println("NO");
	    	else
	    	{	if(q%n==0&&(n!=a[0]&&n!=a[1]))
	    	{	System.out.println("YES");
	    		System.out.println(a[0]+" "+a[1]+" "+n);
	    	}
	    	else
	    		System.out.println("NO");
	    	}
	    }
		}
	
	}