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 
"""
    This template is made by Satwik_Tiwari.
    python programmers can use this template :)) .
"""

#===============================================================================================
#importing some useful libraries.

import sys
import bisect
import heapq
from math import *
from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl #
from bisect import bisect_right as br
from bisect import bisect

#===============================================================================================
#some shortcuts

mod = pow(10, 9) + 7
def inp(): return sys.stdin.readline().strip() #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)


#===============================================================================================
# code here ;))
def sieve(a): #O(n loglogn) nearly linear
    #all odd mark 1
    for i in range(3,((10**5)+1),2):
        a[i] = 1
    #marking multiples of i form i*i 0. they are nt prime
    for i in range(3,((10**5)+1),2):
        for j in range(i*i,((10**5)+1),i):
            a[j] = 0
    a[2] = 1 #special left case
    return (a)


a = [0]*((10**5)+1)
a = sieve(a)
# print(a[2])
# print(12345**0.5)
def solve():
    n = int(inp())
    i = 3
    f = 0
    while(i*i < n):
        if(n%(i) == 0):
            f = 1
            break
        i +=2
    if(n%2 == 0):
        f = 1
    if(f == 0):
        print('NO')
    else:
        i = 2
        div = []
        cnt = 0
        while((i*i) <n):
            if(n%i==0):
                div.append(i)
                n = n//i
                cnt +=1
            if(cnt == 2):
                break
            i+=1
        if(cnt == 2):
            if(n>div[1]):
                print('YES')
                print(div[0],div[1],n)
            else:
                print('NO')
        else:
            print('NO')


testcase(int(inp()))

