Despite his bad reputation, Captain Flint is a friendly person (at least, friendly to animals). Now Captain Flint is searching worthy sailors to join his new crew (solely for peaceful purposes). A sailor is considered as worthy if he can solve Flint's task.

Recently, out of blue Captain Flint has been interested in math and even defined a new class of integers. Let's define a positive integer x as nearly prime if it can be represented as p ⋅ q, where 1 < p < q and p and q are prime numbers. For example, integers 6 and 10 are nearly primes (since 2 ⋅ 3 = 6 and 2 ⋅ 5 = 10), but integers 1, 3, 4, 16, 17 or 44 are not.

Captain Flint guessed an integer n and asked you: can you represent it as the sum of 4 different positive integers where at least 3 of them should be nearly prime.

Uncle Bogdan easily solved the task and joined the crew. Can you do the same?

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

Next t lines contain test cases — one per line. The first and only line of each test case contains the single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number Flint guessed.

Output

For each test case print: 

  * YES and 4 different positive integers such that at least 3 of them are nearly prime and their sum is equal to n (if there are multiple answers print any of them); 
  * NO if there is no way to represent n as the sum of 4 different positive integers where at least 3 of them are nearly prime. 

You can print each character of YES or NO in any case.

Example

Input


7
7
23
31
36
44
100
258


Output


NO
NO
YES
14 10 6 1
YES
5 6 10 15
YES
6 7 10 21
YES
2 10 33 55
YES
10 21 221 6

Note

In the first and second test cases, it can be proven that there are no four different positive integers such that at least three of them are nearly prime.

In the third test case, n=31=2 ⋅ 7 + 2 ⋅ 5 + 2 ⋅ 3 + 1: integers 14, 10, 6 are nearly prime.

In the fourth test case, n=36=5 + 2 ⋅ 3 + 2 ⋅ 5 + 3 ⋅ 5: integers 6, 10, 15 are nearly prime.

In the fifth test case, n=44=2 ⋅ 3 + 7 + 2 ⋅ 5 + 3 ⋅ 7: integers 6, 10, 21 are nearly prime.

In the sixth test case, n=100=2 + 2 ⋅ 5 + 3 ⋅ 11 + 5 ⋅ 11: integers 10, 33, 55 are nearly prime.

In the seventh test case, n=258=2 ⋅ 5 + 3 ⋅ 7 + 13 ⋅ 17 + 2 ⋅ 3: integers 10, 21, 221, 6 are nearly prime.
# Author : devil9614 - Sujan Mukherjee

from __future__ import division, print_function

import os,sys
import math
import collections
from itertools import permutations
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
class my_dictionary(dict):
    def __init__(self):
        self = dict()
    def add(self,key,value):
        self[key] = value


def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())

def dmain():
    sys.setrecursionlimit(100000000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()
    
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *,threading
#from itertools import permutations
#Copy 2D list  m = [x[:] for x in mark] .. Avoid Using Deepcopy

abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1] 
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(n-r))
def binary_search(arr, low, high, x): 
    if high >= low: 
  
        mid = (high + low) // 2
        if arr[mid] == x: 
            return mid 
        elif arr[mid] > x: 
            return binary_search(arr, low, mid - 1, x) 
  
        else: 
            return binary_search(arr, mid + 1, high, x) 
  
    else: 
        return -1
def ceil(x,y):
    if x%y==0:
        return x//y
    else:
        return x//y+1

def powerMod(x,y,p):
    res = 1
    x %= p
    while y > 0:
        if y&1:
            res = (res*x)%p
        y = y>>1
        x = (x*x)%p
    return res

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
    
def isPrime(n) : # Check Prime Number or not 
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True



def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 

def padded_bin_with_complement(x):
    if x < 0:
        return bin((2**16) - abs(x))[2:].zfill(16)
    else:
        return bin(x)[2:].zfill(16)
def binaryToDecimal(binary): 
      
    binary1 = binary 
    decimal, i, n = 0, 0, 0
    while(binary != 0): 
        dec = binary % 10
        decimal = decimal + dec * pow(2, i) 
        binary = binary//10
        i += 1
    print(decimal) 
def CountFrequency(my_list): 
    freq = {} 
    for item in my_list: 
        if (item in freq): 
            freq[item] += 1
        else: 
            freq[item] = 1
  
    return freq 
def pos(a):
    b = [0]*len(a)
    c = sorted(a)
    for i in range(len(a)):
        for j in range(len(a)):
            if c[j] == a[i]:
                b[i] = j
                break
    return b
def smallestDivisor(n): 
  
    # if divisible by 2 
    if (n % 2 == 0): 
        return 2
  
    # iterate from 3 to sqrt(n) 
    i = 3  
    while(i * i <= n): 
        if (n % i == 0): 
            return i 
        i += 2 
  
    return n
def commonn(a,b,n):
    c = []
    for i in range(n):
        if a[i] == b[i]:
            c.append("-1")
        else:
            c.append(b[i])
    return c


def primeFactors(n): 
    j = []
    while n % 2 == 0: 
        j.append(2) 
        n = n / 2
    
    for i in range(3,int(math.sqrt(n))+1,2): 
          
        # while i divides n , print i ad divide n 
        while n % i== 0: 
            j.append(int(n)) 
            n = n / i 
              
    if n > 2: 
        j.append(int(n))
    return j
def sumdigit(n):
    n = str(n)
    k = 0
    for i in range(len(n)):
        k+=int(n[i])
    return k

def question(a,n):
    j = a
    for i in range(n):
        if a[i] == "1":
            j[i] = "0"
        else:
            j[i] = "1"
    j[0,n-1].reverse()
    return j

def main():
    
    for _ in range(ii()):
        n = ii()
        j = [6,10,14]
        if n > sum(j):
            if (n - sum(j)) in j:
                j[2] = 15
            print("YES")
            print(*j,n - sum(j))
        else:
            print("NO")









                                

# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion


if __name__ == "__main__":
    #read()
    main()