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 
rr = raw_input
rri = lambda: int(raw_input())
rrm = lambda: map(int, raw_input().split())

MOD = 10 ** 9 + 7
INF = float('inf')
NINF = float('-inf')
YES, NO = "YES", "NO"
##

def factorize(n):
    d = 2
    facs = []
    while d * d <= n:
        e = 0
        while n % d == 0:
            n //= d
            e += 1
        if e:
            facs.append((d,e))
        d += 1 if d==2 else 2
    if n > 1:
        facs.append((n,1))
    return facs

def solve(N):
    # 2 <= a,b,c  and abc = n or no
    # a,b,c distinct
    facs = factorize(N)
    if len(facs) >= 3:
        a = facs[0][0] ** facs[0][1]
        b = facs[1][0] ** facs[1][1]
        c = 1
        for i in range(2, len(facs)):
            c *= facs[i][0] ** facs[i][1]
        return a,b,c
    if len(facs) == 1:
        p,e = facs[0]
        if e < 6: return None
        a,b,c= p, p*p, p**(e-3)
        return a,b,c
    
    (p1,e1),(p2,e2) = facs
    if e1 == e2 == 1:
        return None
    a = p1
    b = p2
    c = p1**(e1-1)
    c *= p2 **(e2-1)
    if a != b != c != a:
        return a,b,c
    return None

##
T = rri()
for tc in xrange(T):
    ans = solve(rri())
    if ans is None:
        print NO
    else:
        print YES
        print "{} {} {}".format(*ans)
