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 
import java.util.*;
import java.io.*;
public class Main {
      static class pair implements Comparable<pair>{
        int a;
        int b;
        public pair(int a, int b){
            this.a=a;
            this.b=b;
        }
        public int compareTo(pair p){
            return (a-p.a==0)?b-p.b:a-p.a;
        }
          
      }
  public static void main(String[] args) throws IOException,InterruptedException{
	BufferedReader	 br = new BufferedReader(new InputStreamReader(System.in));
	PrintWriter out = new PrintWriter(System.out);
     	// String s = br.readLine();
        // char[] arr=s.toCharArray();
        // ArrayList<Integer> arrl = new ArrayList<Integer>(); 
        // TreeSet<Integer> ts1 = new TreeSet<Integer>(); 
        // HashSet<Integer> h = new HashSet<Integer>(); 
        // HashMap<Integer, Integer> map= new HashMap<>(); 
        // PriorityQueue<String> pQueue = new PriorityQueue<String>(); 
        // LinkedList<String> object = new LinkedList<String>(); 
        // StringBuilder str = new StringBuilder(); 
        //*******************************************************//
 	   //  StringTokenizer   st = new StringTokenizer(br.readLine());
 	   // 	  int t = Integer.parseInt(st.nextToken());
 	   //    while(t-->0){
 	   //        st = new StringTokenizer(br.readLine());
 	   // 	  int n = Integer.parseInt(st.nextToken());
 	   // 	  int[] arr = new int[n];
 	   // 	  st = new StringTokenizer(br.readLine());
 	   // 	  for(int i=0; i<n; i++){
 	   // 	      arr[i] =Integer.parseInt(st.nextToken());
 	   // 	  }
 	   // 	  int ans =0;
 	   // 	  out.println(ans);
 	   //    }
 	         
 	           StringTokenizer   st = new StringTokenizer(br.readLine());
 	    	  int t = Integer.parseInt(st.nextToken());
 	      loop: while(t-->0){
 	      st = new StringTokenizer(br.readLine());
 	    
 	     int n = Integer.parseInt(st.nextToken());
 	     Factors(n);
 	      }
 	         
 	   	  out.flush();
 	      }
    static void Factors(int n) 
{   int k =n;
    ArrayList<Integer> P = new ArrayList<Integer>(); 
      while (n % 2 == 0) 
    { 
        P.add(2); 
        n /= 2; 
    } 
      for (int i = 3; i * i <= n; i = i + 2) 
    { 
        while (n % i == 0) 
        { 
            n = n / i; 
            P.add(i); 
        } 
    } 
    if (n > 2) 
        P.add(n); 
    if (P.size() < 3) 
    { 
        System.out.println("NO"); 
        return; 
    } 
    HashSet<Integer> h = new HashSet<Integer>(); 
    int pro = 1;
    int i =0;
      for (; i<P.size()&&h.size()<2; i++) {
          pro*=(int)P.get(i);
        if(!h.contains(pro)){h.add(pro); pro =1;}
      }
    int product = 1; 
    for (; i < P.size(); i++) 
        product = product * (int)P.get(i); 
        if(product!=1)h.add(product);
        if(h.size()==3){
             Iterator value = h.iterator();
          StringBuilder str = new StringBuilder(); 
          int check =1;
         while (value.hasNext()) { 
            int x =(int)value.next();
            check*=x;
            str.append(x+" ");
        }
        if(check==k){System.out.println("YES");System.out.println(str);}
        else System.out.println("NO"); 
        }else System.out.println("NO"); 
} 
}