Nastia has 2 positive integers A and B. She defines that:

  * The integer is good if it is divisible by A ⋅ B; 
  * Otherwise, the integer is nearly good, if it is divisible by A. 



For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.

Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z.

Input

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

The first line of each test case contains two integers A and B (1 ≤ A ≤ 10^6, 1 ≤ B ≤ 10^6) — numbers that Nastia has.

Output

For each test case print: 

  * "YES" and 3 different positive integers x, y, and z (1 ≤ x, y, z ≤ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z. 
  * "NO" if no answer exists. 

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

If there are multiple answers, print any.

Example

Input


3
5 3
13 2
7 11


Output


YES
10 50 60
YES
169 39 208
YES
28 154 182

Note

In the first test case: 60 — good number; 10 and 50 — nearly good numbers.

In the second test case: 208 — good number; 169 and 39 — nearly good numbers.

In the third test case: 154 — good number; 28 and 182 — nearly good numbers.
#------------------Important Modules------------------#
from sys import stdin,stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
from random import *
from itertools import permutations
input=stdin.readline
prin=stdout.write
from random import sample
from collections import Counter,deque
from fractions import *
from math import sqrt,ceil,log2,gcd,cos,pi,floor
from copy import deepcopy
#dist=[0]*(n)
mod=10**9+7
mod2=998244353
def ps(n):
    cp=0;lk=0;arr={}
    lk=0;ap=n
    cc=0
    while n%2==0:
        n=n//2
        cc=1
    if cc==1:
        lk+=1
        
    
    
    
        
    for ps in range(3,ceil(sqrt(n))+1,2):
        #print(ps)
        cc=0
        while n%ps==0:
            n=n//ps
            cc=1

        lk+=1 if cc==1 else 0
        
            
            
    if n!=1:
        lk+=1
    
    if lk==1:    
        return False
        
    
    #print(arr)
    
    return True


#count=0
#dp=[[0 for i in range(m)] for j in range(n)]
#[int(x) for x in input().strip().split()]
def gcd(x, y): 
      
    while(y): 
        x, y = y, x % y 
      
    return x 
          
# Driver Code         
def factorials(n,r):
    #This calculates ncr mod 10**9+7
    slr=n;dpr=r
    qlr=1;qs=1
    mod=10**9+7
    
    for ip in range(n-r+1,n):
        qlr=(qlr*ip)%mod
    for ij in range(1,r):
        qs=(qs*ij)%mod
    #print(qlr,qs)
    ans=(qlr*modInverse(qs))%mod
    return ans

        
        
def modInverse(b):
    qr=10**9+7
    return pow(b, qr - 2,qr)

#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
  def wrapped_func(*args, **kwargs):
    if stack: return f(*args, **kwargs)
    to = f(*args, **kwargs)
    while True:
      if type(to) is GeneratorType:
        stack.append(to)
        to = next(to)
        continue
      stack.pop()
      if not stack: break
      to = stack[-1].send(to)
    return to
  return wrapped_func
def power(arr):
  listrep = arr
  subsets = []
  for i in range(2**len(listrep)):
    subset = []
    for k in range(len(listrep)):            
      if i & 1<<k:
        subset.append(listrep[k])
    subsets.append(subset)        
  return subsets
def pda(n) :
    list=[];su=0
    for i in range(1, int(sqrt(n) + 1)) :
         if (n % i == 0) :
            if (n // i == i) :
                list.append(i)
                su+=i
            else :
                list.append(n//i);list.append(i)
                su+=i;su+=n//i
    # The list will be printed in reverse    
    return su
def dis(xa,ya,xb,yb):
    return sqrt((xa-xb)**2+(ya-yb)**2)
#### END ITERATE RECURSION ####

 
#===============================================================================================
#----------Input functions--------------------#
def ii():
    return int(input())
def ilist():
    return [int(x) for x in input().strip().split()]
def islist():
    return list(map(str,input().split().rstrip()))
def inp():
    return input().strip()
def google(test):
    return "Case #"+str(test)+": ";
def overlap(x1,y1,x2,y2):
    if x2>y1:
        return y1-x2
    if y1>y2:
        return y2-x2
    return y1-x2;


###-------------------------CODE STARTS HERE--------------------------------###########

        
    

def dist(x1,y1,x2,y2):
    return sqrt((x1-x2)**2+(y1-y2)**2)
def sieve(n):
      
    
    prime = [True for i in range(n + 1)]
    p = 2
    while (p * p <= n):
          
        
        if (prime[p] == True):
              
            
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 1
    prime[0]= False
    prime[1]= False
    ans=[]
    for i in range(1,n+1):
        if prime[i]:
            ans.append(i)
    return ans
        
            
def prod(arr):
    n=len(arr)
    k=1
    for j in range(n):
        k*=arr[j]
    return k
def SumOfDigits(s):
    su=0
    while (s):
        su+=s%10
        s=s//10
    return su
def std():
    return stdout.flush()
    
#########################################################################################
#def valid(sec,hr,min,nano):
def finds(s):
    att=0
    i=1
    while i<len(s):
        att=int(s[:i])
        j=i
        cc=0
        while j<len(s):
            att+=1
            sk=att
            news=str(sk)
            rr=len(news)
            #print(i,j,news,rr,s[j:j+rr])
            if news==s[j:j+rr]:
                #print(i,j,news,rr,s[j:j+rr])
                j+=rr
                
                #continue
            else:
                cc=1
                break
        if cc==0:
            return True
        i+=1
    return False
            
                
                
    
#print(finds('78910'))
arr=[]
for i in range(1,10001):
    s=str(i)
    j=i
    while len(s)<=7:
        j+=1
        s+=str(j)
        arr.append(int(s))

        

arr.sort()    
    
    
def sl(n):
    return (n*(n+1))//2
t=ii()
#t=1


for pl in range(t):
    a,b=ilist()
    if b==1:
        print("NO")
        continue
    print("YES")
    if b!=2:
        
        print(a,a*(b-1),a*b)
    else:
        if b==2:
            if a==3:
                print(3,9,12)
            else:
                print(a**2,a*3,a**2+3*a)
                
    
            
    
                
        
            
        
                    
                    
                    
                        
                    
                    
                    
                
                
            
        
            
        
            
        
    
        
    
        
    
        
    
        
        
        
                
            
                
            
        
        
        
    
    
                
                
        
    
        
        
    
        
    
    
    
    
    
        
                
    
            
            
    
    





















    
