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.io.*;
import java.util.*;

import static java.lang.Math.max;

public class Main {
    public static void main(String[] args) throws IOException {
        run();
        end();
    }


    static void run() throws IOException {
        int t = nextInt();
        while (t-- > 0) {
            solve(nextInt());
        }
    }

    private static void solve(int n) {
        for (int i = 2; i * i <= n; ++i) {
            if (n % i == 0) {
                for (int j = 2; j * j < n / i; ++j) {
                    if ((n / i) % j == 0 && j != i && n / i / j != i) {
                        out.println("YES");
                        out.println(n / i / j + " " + i + " " + j);
                        return;
                    }
                }
            }
        }
        out.println("NO");
    }

    static class mem {
        int x, y;
    }

    static class comparator implements Comparator<mem> {
        public int compare(mem o1, mem o2) {
            if (o1.x != o2.x)
                return Integer.compare(o1.x, o2.x);
            return Integer.compare(o1.y, o2.y);
        }
    }

    static long stepenb(long a, long b) {
        long h = 1;
        while (b > 0) {
            if (b % 2 != 0) {
                h *= a;
                b--;
            }
            b /= 2;
            a *= a;
        }
        return h;
    }

    static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    private static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static void end() {
        out.flush();
        out.close();
    }

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static PrintWriter out = new PrintWriter(System.out);

    static StringTokenizer in = new StringTokenizer("");

    public static String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null) return null;
            in = new StringTokenizer(s);
        }
        return in.nextToken();
    }


    public static int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
}