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 
from functools import reduce
import io
import os
import sys
from atexit import register
import random
import math
import itertools

##################################### Flags          #####################################
# DEBUG = True
DEBUG = False
STRESSTEST = False
# STRESSTEST = True

##################################### IO             #####################################

if not DEBUG:
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))

tokens = []
tokens_next = 0


def nextStr():
    global tokens, tokens_next
    while tokens_next >= len(tokens):
        tokens = input().split()
        tokens_next = 0
    tokens_next += 1

    if type(tokens[tokens_next - 1]) == str:
        return tokens[tokens_next - 1]
    return tokens[tokens_next - 1].decode()


def nextInt():
    return int(nextStr())


def nextIntArr(n):
    return [nextInt() for i in range(n)]


def print(*argv, end='\n'):
    for arg in argv:
        sys.stdout.write((str(arg) + ' ').encode())
    sys.stdout.write(end.encode())


##################################### Helper Methods #####################################
def genTestCase():
    return random.randint(1, 100)


def bruteforce(n):
    for c in itertools.combinations(range(2, n), 3):
        if reduce(lambda x, y: x * y, c) == n:
            return list(c)
    return None


def check(mySoln, bruteforceSoln):
    if bruteforceSoln is None or mySoln == None:
        return mySoln == bruteforceSoln

    n = reduce(lambda x, y: x * y, bruteforceSoln)
    return mySoln[0] * mySoln[1] * mySoln[2] == n and len(set(mySoln)) == 3


def doStressTest():
    while True:
        curTest = genTestCase()
        mySoln = solve(curTest)
        bruteforceSoln = bruteforce(curTest)
        if not check(mySoln, bruteforceSoln):
            print('### Found case ###')
            print(curTest)
            print(f'{mySoln} should have been: {bruteforceSoln}')
            return


def genPrimes(limit):
    limit = int(limit)
    isPrime = [0, 0] + [1] * (limit + 10)
    for i in range(len(isPrime)):
        if isPrime[i]:
            yield i
            for j in range(i * i, len(isPrime), i):
                isPrime[j] = 0


primes = [i for i in genPrimes(10**5)]


def factorize(n):
    res = []
    ps = iter(primes)
    while n > 1:
        p = next(ps, -1)
        if p == -1:
            res.append(n)
            break
        while n % p == 0:
            n = n // p
            res.append(p)
    return res


def solve(n):
    factors = factorize(n)
    if len(factors) > 2:
        p1 = factors[0]
        p2 = next((i for i in factors if i != p1), -1)
        if p2 == -1:
            p2 = factors[1] * factors[2]
        res = [p1, p2, n // p1 // p2]
        if reduce(lambda x, y: x * y, res) == n and len(
                set(res)) == 3 and 1 not in res:
            return res

    return None


##################################### Driver         #####################################

if __name__ == "__main__":
    if not DEBUG and STRESSTEST:
        raise Exception('Wrong flags!')

    if STRESSTEST:
        doStressTest()
    else:
        ### Read input here
        t = nextInt()
        for _ in range(t):
            n = nextInt()
            res = solve(n)
            if res is None:
                print('NO')
            else:
                print('YES')
                print(' '.join(map(str, res)))

    sys.stdout.flush()