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

The integer is good if it is divisible by $A \cdot 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 \le t \le 10000$) — the number of test cases.

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


-----Output-----

For each test case print:

"YES" and $3$ different positive integers $x$, $y$, and $z$ ($1 \le x, y, z \le 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.


-----Examples-----

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.

Difficulty: EASY
Tags: Number theory

Mathematics

Constructive algorithms

Starter code:

Solutions:
t = int(input())

def hah(a, b):
	if b == 1:
		return False
	return (a * b, a, a * (b + 1))
for _ in range(t):
	(A, B) = [int(x) for x in input().split()]
	c = hah(A, B)
	if c == False:
		print('NO')
	else:
		(x, y, z) = c
		print('YES')
		print(x, end=' ')
		print(y, end=' ')
		print(z)


import math
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ans = n * m
	ans1 = n * (m - 1)
	ans2 = n * 1
	if ans1 + ans2 == ans and ans1 > 0 and (ans2 > 0) and (ans > 0):
		if ans1 == ans2:
			print('YES')
			print(ans1 * 3, ans2 * 1, ans * 2)
		else:
			print('YES')
			print(ans1, ans2, ans)
	else:
		print('NO')


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
from collections import deque
BUFSIZE = 8192
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def main():
	t = int(input())
	for i in range(t):
		(a, b) = map(int, input().split())
		if b == 1:
			print('NO')
		else:
			if b == 2:
				b = 4
			print('YES')
			print(a, a * (b - 1), a * b)
main()


t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	arr = []
	if b == 1:
		print('NO')
	else:
		print('YES')
		arr.append(str(a * b))
		arr.append(str(a))
		arr.append(str((b + 1) * a))
		print(' '.join(arr))


import sys

def solve(a, b):
	if b != 1:
		print('YES')
		if b != 2:
			print(a, a * (b - 1), a * b)
		else:
			print(a, 3 * a, 4 * a)
	else:
		print('NO')
T = int(input())
for t in range(T):
	(a, b) = map(int, input().split())
	solve(a, b)


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	if b == 2:
		b = 4
	tmp = a * b
	print('YES')
	tmp1 = a
	tmp2 = a * (b - 1)
	print(tmp1, tmp2, tmp)


from collections import Counter

def f(l):
	A = [l[i] - i for i in range(len(l))]
	x = Counter(A)
	tot = 0
	for i in x:
		tot += x[i] * (x[i] - 1) / 2
	return int(tot)

def no(a, b):
	if b == 1:
		return 'NO'
	else:
		x = a * (2 * b - 1)
		y = a * (2 * b + 1)
		z = a * 4 * b
		return 'YES\n' + str(x) + ' ' + str(y) + ' ' + str(z)

def foo(x):
	x = x.split()
	for (i, v) in enumerate(x):
		x[i] = int(v)
	return x
i1 = int(input())
ls = []
for a in range(i1):
	r2 = input()
	ans = no(foo(r2)[0], foo(r2)[1])
	ls.append(ans)
for j in ls:
	print(j)


def test(a, b):
	if b == 1:
		print('NO')
		return
	print('YES')
	if b == 2:
		print(a, a * 3, a * 4)
	else:
		print(a, a * (b - 1), a * b)
t = int(input())
for _ in range(t):
	(x, y) = map(int, input().split())
	test(x, y)


for i in range(int(input())):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a, a * b, a * (b + 1))


a = int(input())
for i in range(a):
	(m, n) = map(int, input().split())
	if n == 1:
		print('NO')
	else:
		print('YES')
		print(m * (n - 1), m * (n + 1), 2 * m * n)


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	else:
		print('YES')
		print(a, a * b, a + a * b)


I = lambda : int(input())
tup = lambda : map(int, input().split())
lst = lambda : list(map(int, input().split()))

def solve():
	(a, b) = tup()
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a * b, a, (b + 1) * a)
t = I()
while t:
	solve()
	t -= 1


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	if b == 2:
		b += 1
		print('YES')
		print(a, a * (b - 1), a * b)
	elif b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * (b - 1), a * b)


for i in range(int(input())):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	if b == 1:
		print('NO')
	elif b - 1 == 1:
		print('YES')
		print(str(a * b) + ' ' + str(a) + ' ' + str(a * (b + 1)))
	else:
		print('YES')
		print(str(a) + ' ' + str(a * (b - 1)) + ' ' + str(a * b))


t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		x = a
		y = a * b
		z = a * b + a
		print(x, y, z)


tt = int(input())
for T in range(tt):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(' '.join(list(map(str, [a, a * (2 * b - 1), 2 * a * b]))))


n = int(input())
for i in range(n):
	(a, b) = map(int, input().split())
	c = a * b
	r = c - a
	if b == 1:
		print('NO')
	elif r != a:
		print('YES')
		print(c - a, a, c)
	elif r == a:
		d = 2 * a * b
		print('YES')
		print(d - a, a, d)


for _ in range(int(input())):
	(a, b) = [int(x) for x in input().split()]
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * (b + 1))


t = int(input(''))
while t:
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		if b == 2:
			print(a, a * 3, a * b * 2)
		else:
			print(a, a * (b - 1), a * b)
	t = t - 1


import sys
input = sys.stdin.readline

def solve():
	(A, B) = map(int, input().split())
	x = A * (B - 1)
	y = A * (B + 1)
	z = A * B * 2
	if (x % (A * B) == 0) + (y % (A * B) == 0) + (z % (A * B) == 0) == 1 and x >= 1 and (y >= 1) and (z >= 1):
		print('YES')
		print(x, y, z)
	else:
		print('NO')
for i in range(int(input())):
	solve()


t = int(input())
ans = []
for i in range(t):
	(A, B) = map(int, input().split())
	if B == 1:
		ans.append([-1])
	else:
		ans.append([A, A * B, A * (B + 1)])
for i in range(t):
	if ans[i] == [-1]:
		print('NO')
	else:
		print('YES')
		print(*ans[i])


from os import path
import sys, time
mod = int(1000000000.0 + 7)
maxx = float('inf')
import sys, time, collections as c, math, pprint as p, bisect as bs, functools, operator as op
(nCr, ceill) = (lambda n, r: functools.reduce(op.mul, range(n - r + 1, n + 1), 1) // m.factorial(r), lambda n, x: (n + x - 1) // x)
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
for _ in range(int(input())):
	(a, b) = map(int, input().split())
	(x, y, z) = (a * (b - 1), a * (b + 1), 2 * (a * b))
	(se, ok1, ok2, ok3, fl) = ({x, y, z}, False, False, False, True)
	if len(se) == 3 and len([i for i in se if i]) == 3:
		for i in se:
			if i % (a * b) == 0:
				if not ok1:
					ok1 = True
				else:
					fl = False
			elif i % a == 0:
				if not ok2:
					ok2 = True
				else:
					ok3 = True
		if ok1 and ok2 and ok3 and fl:
			print('YES')
			print(x, y, z)
		else:
			print('NO')
	else:
		print('NO')


T = int(input())
for t in range(T):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * b + a)


import os
import sys
from io import BytesIO, IOBase
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import ceil

def prod(a, mod=10 ** 9 + 7):
	ans = 1
	for each in a:
		ans = ans * each % mod
	return ans

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a * b, a * (b + 1), a * b + a * b + a)


import random
import math
from collections import defaultdict
import itertools
from sys import stdin, stdout
import operator

def main():
	z = ''
	for _ in range(int(stdin.readline())):
		(a, b) = list(map(int, input().split()))
		if b == 1:
			print('NO')
		else:
			print('YES')
			print(a, a * b, a * b + a)
main()


def numbers(a, b):
	if b == 1:
		print('NO')
	else:
		x = str(a * b)
		y = str(a)
		z = str((b + 1) * a)
		w = x + ' ' + y + ' ' + z
		print('YES')
		print(w)
x = int(input())
m = []
for i in range(x):
	y = input()
	z = y.split(' ')
	u = [int(t) for t in z]
	m.append(u)
for j in range(x):
	numbers(m[j][0], m[j][1])


import math
T = int(input())
while T:
	(A, B) = map(int, input().split())
	if B == 1:
		print('NO')
	else:
		z = 2 * B * A
		x = A
		y = z - A
		print('YES')
		print(x, y, z)
	T -= 1


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	res1 = a
	res2 = a * (b - 1)
	res3 = a * b
	if res1 > 0 and res2 > 0 and (res3 > 0):
		print('YES')
		if res1 == res2:
			print(res1, res1 + 2 * res2, 2 * res3)
		else:
			print(res1, res2, res3)
	else:
		print('NO')


import sys
import math
from bisect import bisect_left
from collections import Counter, defaultdict
L = lambda : list(map(int, input().split()))
I = lambda : int(input())
S = lambda : input()
mod = 10 ** 9 + 7

def solve():
	(a, b) = L()
	if a == 1 and b == 1:
		print('NO')
	elif b == 1:
		print('NO')
	elif b == 2:
		print('YES')
		print(a * 1, a * b, a * (b + 1))
	else:
		print('YES')
		print(a * 1, a * (b - 1), a * b)
for _ in range(I()):
	solve()


def solve(a, b):
	if b < 2:
		print('NO')
		return
	print('YES')
	if b == 2:
		z = 2 * a * b
		x = a
		y = 3 * a
	else:
		z = a * b
		y = a * b - a
		x = a
	print(x, y, z)
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	solve(a, b)


import sys
import math
from math import factorial, inf, gcd, sqrt
from heapq import *
from functools import *
from itertools import *
from collections import *
from typing import *
from bisect import *
import random
sys.setrecursionlimit(10 ** 5)

def rarray():
	return [int(i) for i in input().split()]
t = 1
t = int(input())
for ii in range(t):
	(a, b) = rarray()
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a * b, a, a * (b + 1))


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
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):
		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
	return True

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def factorials(n, r):
	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
	ans = qlr * modInverse(qs) % mod
	return ans

def modInverse(b):
	qr = 10 ** 9 + 7
	return pow(b, qr - 2, qr)
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
	return su

def dis(xa, ya, xb, yb):
	return sqrt((xa - xb) ** 2 + (ya - yb) ** 2)

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

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 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)
			if news == s[j:j + rr]:
				j += rr
			else:
				cc = 1
				break
		if cc == 0:
			return True
		i += 1
	return False
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()
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)
	elif b == 2:
		if a == 3:
			print(3, 9, 12)
		else:
			print(a ** 2, a * 3, a ** 2 + 3 * a)


def solve(a, b):
	if b == 1:
		return None
	if b == 2:
		return [a, 3 * a, 4 * a]
	return [a, a * (b - 1), a * b]
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	res = solve(a, b)
	if res:
		print('YES')
		print(*res)
	else:
		print('NO')


def read_one_line_input():
	s = input()
	read_one_line = [int(i) for i in s.split()]
	return read_one_line

def read_lines_input():
	read_in = []
	n = int(input())
	for i in range(n):
		s = input()
		read_one_line = [int(i) for i in s.split()]
		read_in.append(read_one_line)
	return read_in

def print_list(out_list):
	[print(s) for s in out_list]

def get_out(a, b):
	ab = a * b
	sum = a + ab
	if b == 1:
		return -1
	return str(a) + ' ' + str(a * b) + ' ' + str(sum)

def main(read_in):
	out_lines = []
	for line in read_in:
		(a, b) = line
		out = get_out(a, b)
		if out == -1:
			out_lines.append('NO')
		else:
			out_lines.append('YES')
			out_lines.append(out)
	return out_lines
read_in = read_lines_input()
out_list = main(read_in)
print_list(out_list)


def solvecaso():
	(a, b) = map(int, input().split())
	if b <= 1:
		print('NO')
		return 0
	if b == 2:
		b = 4
	print('YES')
	print(a, (b - 1) * a, a * b)
	return 0
casos = int(input())
for caso in range(1, casos + 1):
	result = solvecaso()


def main():
	for _ in range(int(input())):
		(a, b) = map(int, input().split())
		if b == 1:
			print('NO')
			continue
		c = a * b
		z = c * 2
		x = a
		y = z - a
		print('YES')
		print(x, y, z)
main()


num = int(input())
for n in range(num):
	inp = input().split()
	a = int(inp[0])
	b = int(inp[1])
	if b == 1:
		print('NO')
	else:
		print('YES')
		x = 2 * a * b - a
		y = 2 * a * b + a
		print(x, y, x + y)


for _ in range(int(input())):
	(A, B) = map(int, input().split())
	if B == 1:
		print('NO')
	else:
		print('YES')
		print(A * (B - 1), A * B, A * (2 * B - 1))


n = int(input())
for i in range(n):
	l = list(map(int, input().split()))
	if l[1] == 1:
		print('NO')
	else:
		print('YES')
		print(l[0], l[0] * l[1], l[0] * (l[1] + 1))


from sys import *
import sys
from math import *
t = stdin.readline
R = range
p = stdout.write
mod = int(1000000000.0) + 7

def S():
	return t().strip()

def I():
	return int(t())

def GI():
	return map(int, input().strip().split())

def GS():
	return map(str, t().strip().split())

def IL():
	return list(map(int, t().strip().split()))

def SL():
	return list(map(str, t().strip().split()))

def mat(n):
	return [IL() for i in range(n)]

def GM(i):
	return [-9223372036854775808, 9223372036854775808][i]
for _ in range(I()):
	(a, b) = GI()
	if b == 1:
		print('NO')
		continue
	z = 2 * a * b
	(x, y) = (a, z - a)
	print('YES')
	print(x, y, z)


t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	elif b == 2:
		print('YES')
		print(a, ' ', a * 3, ' ', a * 4)
	else:
		print('YES')
		print(a, ' ', a * (b - 1), ' ', a * b)


def solve(A, B):
	if B == 1:
		print('NO')
	else:
		print('YES')
		print(str(A), str(A * B), str(A * (B + 1)))
n = int(input())
for _ in range(n):
	(A, B) = map(int, input().split())
	solve(A, B)


n = int(input())
for _ in range(n):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, b * a, (b + 1) * a)


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	good = a * b
	ngood = a
	nbgood = good + ngood
	if nbgood != good and ngood != good:
		print('YES')
		print(good, ngood, nbgood)
	else:
		print('no')


raw_input = input('')
times = int(raw_input)

def find_result(a, b):
	x = a * b
	y = a
	z = x + y
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(f'{x} {y} {z}')
for t in range(times):
	raw_input = input('')
	(a, b) = raw_input.split(' ')
	find_result(int(a), int(b))


import sys, os, io
import math, bisect, operator, itertools
(inf, mod) = (float('inf'), 10 ** 9 + 7)
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int, input().split()))
(test,) = Neo()
for _ in range(test):
	(a, b) = Neo()
	t = 1
	f = 1
	while t < 10 ** 2:
		s = [a, (t * b - 1) * a, t * a * b]
		if len(set(s)) == 3 and sum([i % (a * b) == 0 for i in s]) == 1:
			print('YES')
			print(*s)
			f = 0
			break
		t += 1
	if f:
		print('NO')


t = int(input())
for tt in range(t):
	(a, b) = list(map(int, input().split()))
	multiple = a * b
	if b == 1:
		print('NO')
	else:
		if b < 2:
			multiple += multiple
		print('YES\n' + str(a), multiple, multiple + a)


for i in range(int(input())):
	(a, b) = map(int, input().split())
	if b == 1:
		ans = 'NO'
	else:
		ans = 'YES'
	if ans == 'YES' and b == 2:
		print(ans)
		print(f'{a} {a * (b - 1) * 3} {a * b * 2}')
	elif ans == 'YES':
		print(ans)
		print(f'{a} {a * (b - 1)} {a * b}')
	else:
		print(ans)


def run(n):
	for i in range(n):
		frun(n)

def frun(n):
	(a, b) = [int(i) for i in input().split(' ')]
	if b == 1:
		print('NO\n')
	else:
		print('YES\n' + str(a) + ' ' + str(a * (2 * b - 1)) + ' ' + str(a * 2 * b) + ' \n')
run(int(input()))


for __ in range(int(input())):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print('%d %d %d' % (a, a * b, a * (b + 1)))


t = int(input())
for i in range(t):
	(inp, n) = map(int, input().split())
	if n == 1:
		print('NO')
	else:
		print('YES')
		print(inp, inp * n, inp * n + inp)


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	z = n * k
	if k == 1:
		print('NO')
	else:
		print('YES')
		if k == 2:
			print(n, 3 * n, 4 * n)
		else:
			print(n, n * (k - 1), n * k)


import math
for t in range(int(input())):
	(a, b) = map(int, input().split())
	m = a * b
	if b == 1:
		print('no')
	else:
		a1 = a * m // math.gcd(a, m)
		a2 = b * m // math.gcd(b, m)
		gud = a1 + a2
		x = a * 2
		y = gud - x
		z = gud
		if x == y:
			x = a * 3
			y = gud - x
			if x > z:
				t = z
				z = x
				x = t
		print('yes')
		print(x, y, z)


from sys import stdin
input = stdin.buffer.readline
t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	if b % 2 == 1:
		x = a * b
		y = a
		z = a * (b - 1)
	else:
		x = a * b * 2
		y = a
		z = a * (b * 2 - 1)
	print('YES')
	print(z, y, x)


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	(a, b) = map(int, sys.stdin.readline().split())
	if b != 1:
		print('YES')
		print(a * b, a, a * (b + 1))
	else:
		print('NO')


import sys, os, io
from sys import stdin, stdout
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import bisect
import math
input = stdin.readline
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

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

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def si():
	return input()

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def mi():
	return map(int, input().split())

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')

def power_set(L):
	cardinality = len(L)
	n = 2 ** cardinality
	powerset = []
	for i in range(n):
		a = bin(i)[2:]
		subset = []
		for j in range(len(a)):
			if a[-j - 1] == '1':
				subset.append(L[j])
		powerset.append(subset)
	powerset_orderred = []
	for k in range(cardinality + 1):
		for w in powerset:
			if len(w) == k:
				powerset_orderred.append(w)
	return powerset_orderred

def fastPlrintNextLines(a):
	print('\n'.join(map(str, a)))

def sortByFirstAndSecond(A):
	A = sorted(A, key=lambda x: x[0])
	A = sorted(A, key=lambda x: x[1])
	return list(A)

def dfs(node, vis, adj, lis):
	lis.append(node)
	vis[node] = 1
	for i in adj[node]:
		if vis[i] == 0:
			dfs(i, vis, adj, lis)

def dfsOfGraph(n, adj):
	lis = []
	vis = [0] * (n + 1)
	for i in range(1, n + 1):
		if vis[i] == 0:
			dfs(i, vis, adj, lis)
	return lis

def bfsOfGraph(n, adj):
	vis = [0] * (n + 1)
	lis = []
	for i in range(1, n + 1):
		if vis[i] == 0:
			queue = [i]
			vis[i] = 1
			while len(queue) > 0:
				node = queue.pop(0)
				lis.append(node)
				for j in adj[node]:
					if vis[j] == 0:
						queue.append(j)
						vis[j] = 1
	return lis
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	(a, b) = mi()
	if b == 1:
		print('NO')
	else:
		x = a
		y = a * b
		z = a * (b + 1)
		print('YES')
		print(x, y, z)
t = ii()
for _ in range(t):
	solve()


for _ in range(0, int(input())):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		x = a * b
		y = a
		z = x + y
		print(str('YES') + '\n' + str(x) + ' ' + str(y) + ' ' + str(z))


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(A, B) = map(int, input().split())
	ANS = [A * (B - 1), A * (B + 1), 2 * A * B]
	if A * (B - 1) % (A * B) == 0 or A * (B + 1) % (A * B) == 0:
		print('NO')
	else:
		print('YES')
		print(*ANS)


for i in range(int(input())):
	(p, q) = map(int, input().split())
	if q != 1:
		print('YES')
		print(p * q, p, p * q + p)
	else:
		print('NO')


import math
MOD = 10 ** 9 + 7
sv = math.sqrt(5)
fip = (1 + sv) / 2
fin = (1 - sv) / 2
F = lambda i: (fip ** i - fin ** i) // sv
L = lambda i: (fip ** i + fin ** i) // 1
ln = len

def pfs(n):
	fs = []
	i = 2
	while i * i <= n:
		while n % i == 0:
			n = n // i
			factors.append(i)
		i += 1
	return (factors + [n] * (n != 1))[::-1]

def in_var(to: type):
	return to(input())

def in_arr(to: type):
	return list(map(to, input().split()))

def in_ivar():
	return in_var(int)

def in_iarr():
	return in_arr(int)

def solve():
	(A, B) = in_iarr()
	x = A * (2 * B - 1)
	y = A
	z = x + y
	if x == y:
		print('NO')
		return
	print('YES')
	print(x, y, z)

def main():
	for _ in range(in_ivar()):
		solve()
	return
main()


from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math
import threading
import sys
import time

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))

def solve():
	(A, B) = get_tuple()
	(x, y, z) = (A, A * B, A * (B + 1))
	if z % (A * B) == 0:
		print('NO')
	else:
		print('YES')
		print(x, y, z)
testcases = True
if testcases:
	t = get_int()
	for _ in range(t):
		solve()
else:
	solve()


t = int(input())
import sys
from sys import stdin
for i in range(t):
	arr = list(map(int, stdin.readline().strip().split()))
	if arr[1] == 1:
		print('NO')
	else:
		print('YES')
		print(str(arr[0]) + ' ' + str(arr[0] * arr[1]) + ' ' + str(arr[0] * arr[1] + arr[0]))


t = int(input())

def main(A, B):
	(k1, k2, k3, e) = (0, 0, 1, 0)
	if B == 1:
		return ['NO']
	else:
		while True:
			k3 += 1
			while True:
				k1 += 1
				k2 = B * k3 - k1
				if k2 % B != 0:
					if k1 % B != 0:
						e = 1
						break
			if e == 1:
				break
		(x, y, z) = (k1 * A, k2 * A, k3 * A * B)
	return ['YES', x, y, z]
result = []
for i in range(0, t):
	now = input().split()
	(A, B) = (int(now[0]), int(now[1]))
	result.append(main(A, B))
for i in range(0, t):
	len0 = result[i].__len__()
	print(result[i][0])
	if len0 > 1:
		print('{0} {1} {2}'.format(result[i][1], result[i][2], result[i][3]))


t = int(input())
for test in range(t):
	(a, b) = [int(e) for e in input().split()]
	if b == 1:
		print('NO')
	elif b == 2:
		print('YES')
		x = a
		y = 3 * a
		z = 4 * a
		print('%d %d %d' % (x, y, z))
	else:
		print('YES')
		x = (b - 1) * a
		y = a
		z = a * b
		print('%d %d %d' % (x, y, z))


from sys import stdin as inp
for t in range(int(inp.readline())):
	(a, b) = list(map(int, inp.readline().split()))
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a * b, a * (b + 1), a * (2 * b + 1))


for i in range(int(input())):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print('%d %d %d' % (a * b + a, a * b - a, 2 * a * b))


t = int(input())
for hh in range(0, t):
	(a, b) = [int(x) for x in input().split()]
	if b == 1:
		print('NO')
	elif b == 2:
		x = a
		y = 3 * a
		z = 4 * a
		print('YES')
		print(x, y, z)
	else:
		mna = a
		mnab = a * b
		z = a * b
		x = a
		y = z - x
		print('YES')
		print(x, y, z)


t = int(input())
for _ in range(t):
	(n, k) = tuple(map(int, input().split(' ')))
	if k == 1:
		print('NO')
	else:
		print('YES')
		print(n, n * k, n * k + n)


import sys

def get_int():
	return int(sys.stdin.readline())

def get_string():
	return sys.stdin.readline().strip()
FILE = False
if FILE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
t = get_int()
for i in range(t):
	(a, b) = get_string().split()
	a = int(a)
	b = int(b)
	if b == 1:
		sys.stdout.write('NO\n')
		continue
	else:
		sys.stdout.write('YES\n')
		x = a
		y = a * b
		z = a * (b + 1)
		answer = str(x) + ' ' + str(y) + ' ' + str(z) + '\n'
		sys.stdout.write(answer)


t = int(input())
for i in range(t):
	(a, b) = input().split()
	a1 = int(a)
	b1 = int(b)
	if b1 == 1:
		print('NO')
	else:
		print('YES')
		print(2 * (a1 * b1) - a1, end=' ')
		print(a1, end=' ')
		print(2 * (a1 * b1))


for i in range(int(input())):
	(a, b) = [int(x) for x in input().split()]
	if a == 1 and b == 1:
		print('NO')
	elif b == 1:
		print('NO')
	elif b == 2:
		print('YES')
		print(a * 13, a * 3, a * 2 * 8)
	else:
		print('YES')
		print(a, (b - 1) * a, a * b)


for nt in range(int(input())):
	(A, B) = map(int, input().split())
	if B == 1:
		print('NO')
		continue
	print('YES')
	print(A * (B - 1), A * (B + 1), 2 * A * B)


import sys

def read_numbers():
	return [int(item) for item in sys.stdin.readline().strip().split()]
t = read_numbers()[0]
for _ in range(t):
	(a, b) = read_numbers()
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(f'{a} {(2 * b - 1) * a} {2 * a * b}')


import sys
from sys import stdout
input = lambda : sys.stdin.readline().rstrip('\r\n')
P = lambda : list(map(int, input().split()))
from math import factorial as f, log2, gcd
mod = 10 ** 9 + 7
tc = int(input())
for _ in range(tc):
	(a, b) = P()
	if b != 1:
		print('YES')
		print(a, a * b, a * (b + 1))
	else:
		print('NO')


from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop
from functools import lru_cache
import math
rl = lambda : stdin.readline()
rll = lambda : stdin.readline().split()
rli = lambda : map(int, stdin.readline().split())
rlf = lambda : map(float, stdin.readline().split())
(INF, NINF) = (float('inf'), float('-inf'))
MOD = 10 ** 9 + 7

def main():
	T = int(rl())
	for __ in range(T):
		(a, b) = rli()
		if b == 1:
			print('NO')
			continue
		r = 0
		flag = False
		(x, y, z) = (-1, -1, -1)
		xx = a * b
		while True:
			r += 1
			if r >= 10 ** 8:
				break
			beta = r * b - 1
			if beta >= 10 ** 8:
				break
			y = a * (r * b - 1)
			if y % xx == 0:
				continue
			x = a
			z = a * b * r
			if x == y or y == z or x == z:
				continue
			flag = True
			break
		if flag:
			print('YES')
			print(x, y, z)
		else:
			print('NO')
	stdout.close()
main()


def read_one_line_input():
	s = input()
	read_one_line = [int(i) for i in s.split()]
	return read_one_line

def read_lines_input():
	read_in = []
	n = int(input())
	for i in range(n):
		s = input()
		read_one_line = [int(i) for i in s.split()]
		read_in.append(read_one_line)
	return read_in

def print_list(out_list):
	[print(s) for s in out_list]

def get_out(a, b):
	max = 10 ** 18
	max_j = max // a - b
	for j in range(1, min(b, max_j)):
		if j % b != 0:
			break
	else:
		return -1
	if a * (j + b) > max:
		return -1
	return str(a * j) + ' ' + str(a * b) + ' ' + str(a * j + a * b)

def main(read_in):
	out_lines = []
	for line in read_in:
		(a, b) = line
		out = get_out(a, b)
		if out == -1:
			out_lines.append('NO')
		else:
			out_lines.append('YES')
			out_lines.append(out)
	return out_lines
read_in = read_lines_input()
out_list = main(read_in)
print_list(out_list)


from sys import stdin
input = stdin.readline
from heapq import heapify, heappush, heappop, heappushpop
from collections import defaultdict as dd, deque as dq, Counter as C
from math import factorial as f, ceil, gcd, sqrt, log
from bisect import bisect_left as bl, bisect_right as br
from itertools import combinations as c, permutations as p
from math import factorial as f, ceil, gcd, sqrt, log
mi = lambda : map(int, input().split())
ii = lambda : int(input())
li = lambda : list(map(int, input().split()))
mati = lambda r: [li() for _ in range(r)]
lcm = lambda a, b: a * b // gcd(a, b)

def solve():
	(a, b) = mi()
	if b != 1:
		print('YES')
		print(a, a * b, a * (b + 1))
	else:
		print('NO')
for _ in range(ii()):
	solve()


from math import *
sInt = lambda : int(input())
mInt = lambda : map(int, input().split())
lInt = lambda : list(map(int, input().split()))
t = sInt()
for _ in range(t):
	(a, b) = mInt()
	x = a * b
	y = a
	z = x + y
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(x, y, z)


import math
import sys
import collections
import bisect
import time
import random
from itertools import permutations

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
for t in range(int(input())):
	(a, b) = get_ints()
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a, a * b, a * (b + 1))


import math
from collections import defaultdict, Counter
from itertools import permutations

def fact(n):
	return 1 if n == 1 or n == 0 else n * fact(n - 1)

def prime(n):
	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 inp():
	l = list(map(int, input().split()))
	return l

def main():
	for _ in range(int(input())):
		(a, b) = inp()
		if b == 1:
			print('NO')
		else:
			print('YES')
			print(a * (4 * b - 1), a, a * b * 4)
import os, sys
from io import BytesIO, IOBase
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)


T = int(input())
for x in range(T):
	c = [int(y) for y in input().split()]
	a = c[0]
	b = c[1]
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a * (b - 1), a * (b + 1), a * 2 * b)


def solve(a, b):
	if b == 1:
		return 'NO'
	return f'YES\n{a} {a * (b * 2 - 1)} {a * b * 2}'
for _ in range(int(input())):
	(a, b) = map(int, input().split())
	print(solve(a, b))


t = int(input())
for _ in range(t):
	(A, B) = [int(x) for x in input().split()]
	if B == 1:
		print('NO')
	elif B == 2:
		print('YES')
		print('{} {} {} '.format(A * B, A, A * (B + 1)))
	else:
		print('YES')
		print('{} {} {} '.format(A, (B - 1) * A, A * B))


mod = 10 ** 9 + 7

def solve():
	(a, b) = map(int, input().split())
	x = 0
	y = 0
	z = 0
	if b > 1:
		x = a * (2 * b - 1)
		y = a * (2 * b + 1)
		z = x + y
		print('YES')
		print(x, y, z)
	else:
		print('NO')
t = 1
t = int(input())
while t > 0:
	solve()
	t -= 1


arr = []
for i in range(int(input())):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	arr.append((a, b))
for (p, q) in arr:
	counter = 1
	x = p * (counter * q - 1)
	y = p * 1
	z = p * q * counter
	while x == y:
		counter += 1
		x = p * (counter * q - 1)
		y = p * 1
		z = p * q * counter
	if x + y == z and x != 0 and (y != 0) and (z != 0):
		print('YES')
		print(x, y, z)
	else:
		print('NO')


n = int(input())
inputs = []
for i in range(n):
	inp = input()
	inputs.append([int(item) for item in inp.split(' ')])
for item in inputs:
	if item[1] == 1:
		print('NO')
	else:
		print('YES')
		print(item[0], ' ', item[0] * item[1], ' ', item[0] * (item[1] + 1))


import sys
import math
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		(A, B) = [int(x) for x in input().split()]
		if B == 1:
			print('NO')
			continue
		x = A
		z = B * A
		if B == 2:
			z *= 2
		y = z - x
		print('YES')
		print(x, y, z)
main()


selam = int(input())
input_list = list()
for i in range(selam):
	(a, b) = input().split()
	input_list.append((int(a), int(b)))
for (a, b) in input_list:
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * b + a)


t = int(input())
for i in range(t):
	l = [int(i) for i in input().split()]
	a = l[0]
	b = l[1]
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * (b + 1))


from math import ceil

def slv(a, b):
	if b == 1:
		print('NO')
		return
	print('YES')
	print(a, a * (2 * b - 1), 2 * a * b)
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	slv(a, b)


import sys
t = sys.stdin.readlines()
for i in range(1, int(t[0]) + 1):
	(a, b) = map(int, t[i].split())
	x = a * b
	y = a
	z = a * (1 + b)
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(x, y, z)


from io import BytesIO, IOBase
from math import sqrt
import sys, os
from os import path
inpl = lambda : list(map(int, input().split()))
inpm = lambda : map(int, input().split())
inpi = lambda : int(input())
inp = lambda : input()
(rev, ra, l) = (reversed, range, len)
P = print
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def B(n):
	return bin(n).replace('0b', '')

def factors(n):
	arr = []
	for i in ra(2, int(sqrt(n)) + 1):
		if n % i == 0:
			arr.append(i)
			if i * i != n:
				arr.append(int(n / i))
	return arr

def dfs(arr, n):
	pairs = [[i + 1] for i in ra(n)]
	vis = [0] * (n + 1)
	for i in ra(l(arr)):
		pairs[arr[i][0] - 1].append(arr[i][1])
	pairs[arr[i][1] - 1].append(arr[i][0])
	comp = []
	for i in ra(n):
		stack = [pairs[i]]
		temp = []
		if vis[stack[-1][0]] == 0:
			while len(stack) > 0:
				if vis[stack[-1][0]] == 0:
					temp.append(stack[-1][0])
					vis[stack[-1][0]] = 1
					s = stack.pop()
					for j in s[1:]:
						if vis[j] == 0:
							stack.append(pairs[j - 1])
				else:
					stack.pop()
			comp.append(temp)
	return comp
from bisect import bisect_left as bl
from bisect import bisect_right as br
import sys, operator, math, operator
from collections import Counter
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
import random
tc = inpi()
while tc:
	tc -= 1
	(a, b) = inpm()
	if b == 1:
		P('NO')
	else:
		P('YES')
		P(a * b, a, a * b + a)


tcs = int(input())
for tc in range(tcs):
	(x, y) = list(map(int, input().split()))
	if y == 1:
		print('NO')
		continue
	print('YES')
	(a, b, c) = (1, y - 1, 1)
	if y == 2:
		(a, b, c) = (1, 3, 2)
	print(x * a, x * b, x * y * c)


import random
import collections
import string
import math
import copy
import os
import sys
from io import BytesIO, IOBase
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')
mo = 998244353

def exgcd(a, b):
	if not b:
		return (1, 0)
	(y, x) = exgcd(b, a % b)
	y -= a // b * x
	return (x, y)

def getinv(a, m):
	(x, y) = exgcd(a, m)
	return -1 if x == 1 else x % m

def comb(n, b):
	res = 1
	b = min(b, n - b)
	for i in range(b):
		res = res * (n - i) * getinv(i + 1, mo) % mo
	return res % mo

def quickpower(a, n):
	res = 1
	while n:
		if n & 1:
			res = res * a % mo
		n >>= 1
		a = a * a % mo
	return res

def dis(a, b):
	return abs(a[0] - b[0]) + abs(a[1] - b[1])

def getpref(x):
	if x > 1:
		return x * (x - 1) >> 1
	else:
		return 0

def orafli(upp):
	primes = []
	marked = [False for i in range(upp + 3)]
	prvs = [i for i in range(upp + 3)]
	for i in range(2, upp):
		if not marked[i]:
			primes.append(i)
		for j in primes:
			if i * j >= upp:
				break
			marked[i * j] = True
			prvs[i * j] = j
			if i % j == 0:
				break
	return (primes, prvs)

def lower_ord(c: str) -> int:
	return ord(c) - 97

def upper_ord(c: str) -> int:
	return ord(c) - 65

def read_list():
	return [int(i) for i in input().split()]

def read_int():
	s = input().split()
	if len(s) == 1:
		return int(s[0])
	else:
		return map(int, s)

def ask(s):
	print(f'? {s}', flush=True)

def answer(s):
	print(f'{s}', flush=True)
import functools
import itertools
from fractions import Fraction

def solve():
	(a, b) = read_int()
	if b == 1:
		print('NO')
		return
	if b > 2:
		print('YES')
		print(a * (b - 1), a, a * b)
	elif b == 2 and a & 1 == 0:
		print('YES')
		print(a, 3 * a, 4 * a)
	else:
		print('YES')
		print(a, 3 * a, 4 * a)
t = int(input())
for ti in range(t):
	solve()


n = int(input())
for i in range(n):
	(n, k) = map(int, input().split())
	if k != 1:
		print('YES')
		print(n, n * k, n * (k + 1))
	else:
		print('NO')


from sys import *
input = stdin.readline
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	x = a
	y = a * b
	z = a * b + a
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(x, y, z)


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	if b != 1 and b != 2:
		x = a
		y = (b - 1) * a
		z = a * b
		print('YES')
		print(x, y, z)
	elif b == 2:
		x = a
		y = 3 * a
		z = a * 4
		print('YES')
		print(x, y, z)
	else:
		print('NO')


import heapq, math
from collections import defaultdict, deque
import sys, os.path
if os.path.exists('C:/Users/Dhanush/Desktop/cp/input.txt'):
	sys.stdout = open('C:/Users/Dhanush/Desktop/cp/output.txt', 'w')
	sys.stdin = open('C:/Users/Dhanush/Desktop/cp/input.txt', 'r')
input = sys.stdin.readline
maxi = 10 ** 18
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		c1 = a
		c2 = (b - 1) * a
		c3 = a * b
		if c1 == c2 or c2 == c3 or c1 == c3 or (c1 % (a * b) == 0) or (c2 % (a * b) == 0):
			z = 2
			f = 0
			while 1:
				x = 1
				y = z * b - 1
				c1 = a
				c2 = y * a
				c3 = z * a * b
				if c2 > maxi or c3 > maxi:
					break
				if c1 != c2 and c2 != c3 and (c1 != c3) and (c2 % (a * b) != 0):
					f = 1
					print('YES')
					print(c1, c2, c3)
					break
				z += 1
			if f == 0:
				print('NO')
		else:
			print('YES')
			print(c1, c2, c3)


from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a, a * b, a * (b + 1))


t = int(input())
for i in range(t):
	ab = input().split(' ')
	a = int(ab[0])
	b = int(ab[1])
	if a == 0 or b == 0:
		print('NO')
		continue
	if a * b == a or a == a * (b + 1) or b == b + 1:
		print('NO')
		continue
	print('YES')
	print(str(a * b) + ' ' + str(a) + ' ' + str(a * (b + 1)))


task_num = int(input().strip())
for task_id in range(task_num):
	num_list = list(map(int, input().strip().split()))
	A = num_list[0]
	B = num_list[1]
	if B > 1:
		print('YES')
		print(str(A) + ' ' + str(A * B) + ' ' + str(A * (B + 1)))
	else:
		print('NO')


def solve():
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * (b + 1))
for t in range(0, int(input())):
	solve()


T = int(input())
while T:
	T -= 1
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	if b == 1:
		print('NO')
		continue
	print('YES')
	A = a * b
	B = a
	C = A + B
	print('%d' % A, '%d' % B, '%d' % C)


li = lambda : list(map(int, input().split()))
lis = lambda : sorted(list(map(int, input().split())))
mp = lambda : map(int, input().split())
it = lambda : int(input())
st = lambda : str(input())
from collections import Counter

def twopointers(A, N, X):
	i = 0
	j = N - 1
	while i < j:
		if A[i] + A[j] == X:
			return True
		elif A[i] + A[j] < X:
			i += 1
		else:
			j -= 1
	return 0

def shortest_path(k, n, neighbors):
	mark = [-1] * (n + 1)
	mark[k] = 0
	bfs_queue = [k]
	i = 0
	while i < len(bfs_queue):
		u = bfs_queue[i]
		for v in neighbors[u]:
			if mark[v] == -1:
				mark[v] = mark[u] + 1
				bfs_queue.append(v)
		i += 1
	return mark

def main():
	(a, b) = mp()
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * (b + 1))
for __ in range(it()):
	main()


import sys
import math
from collections import defaultdict as dd
from sys import stdin
input = stdin.readline
m = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 5)
T = int(input())
for _ in range(T):
	(x, y) = map(int, input().split())
	if y == 1:
		print('NO')
	elif y == 2:
		print('YES')
		print(x, x * 3, x * 4)
	else:
		print('YES')
		print(x, x * (y - 1), x * y)


import math
t = int(input())
for _ in range(0, t):
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		if b == 2:
			print(a * 3, a * 5, 8 * a)
		else:
			print(a, a * (b - 1), a * b)


t = int(input())
for _ in range(t):
	arr = list(map(int, input().split()))
	a = arr[0]
	b = arr[1]
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a, a * b, a * (b + 1))


t = int(input())
res = ''
for x in range(t):
	(a, b) = map(int, input().split())
	if b == 1:
		res += 'NO\n'
	else:
		res += 'YES\n' + str(a * b) + ' ' + str(a) + ' ' + str(a * b + a) + '\n'
print(res)


nn = int(input())
while nn != 0:
	(a, b) = map(int, input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a * (b + 1))
	nn -= 1


import sys

def good_ngood(n: list) -> str:
	(a, b) = (int(n[0]), int(n[1]))
	if b == 1:
		return 'NO' + '\n'
	x = a * b
	y = a
	z = x + y
	return str('YES') + '\n' + str(x) + ' ' + str(y) + ' ' + str(z) + '\n'
test = int(sys.stdin.readline())
for i in range(test):
	sys.stdout.write(good_ngood(sys.stdin.readline().split()))


res = ''
for _ in range(int(input())):
	(a, b) = map(int, input().split())
	f = s = t = 0
	if b == 1:
		res += 'NO\n'
	else:
		res += 'YES\n%d %d %d\n' % (a, a * b, a * b + a)
print(res)


n = int(input())
for i in range(0, n):
	(a, b) = (int(x) for x in input().split())
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * b, a + a * b)


cases = int(input())
for case in range(0, cases):
	array = [int(x) for x in input().split(' ')]
	a = array[0]
	b = array[1]
	if b == 1:
		print('No')
		continue
	print('Yes')
	x = a
	y = 5 * a * b - a
	z = x + y
	print(x, y, z)


t = int(input())
for i in range(1, t + 1):
	(a, b) = list(map(int, input().strip().split()))
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(a, a * b, a * (b + 1))


import sys
import time
import itertools
import math

def inp():
	ln = input().split()
	return int(ln[0]) if len(ln) == 1 else [int(i) for i in ln]

def prl(x):
	print(' '.join([str(i) for i in x]))
testcases = inp()
for testcase in range(testcases):
	(a, b) = inp()
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a, a * (b - 1) + a * b, 2 * a * b)


for _ in range(int(input())):
	(a, b) = list(map(int, input().split()))
	x = a
	y = a * (b - 1)
	if x == y:
		y = a * 3 * (b - 1)
	if (x > int(1e+18) or y > int(1e+18) or x + y > int(1e+18)) or 1 == b:
		print('NO')
	else:
		print('YES')
		print(x, y, x + y)


import sys
t = int(sys.stdin.readline())
for i in range(t):
	(a, b) = map(int, sys.stdin.readline().split())
	if b == 1:
		print('NO')
		continue
	print('YES')
	print(f'{a} {a * b} {a + a * b}')


import sys
import math

def scan(input_type='int'):
	if input_type == 'int':
		return list(map(int, sys.stdin.readline().strip().split()))
	else:
		return list(map(str, sys.stdin.readline().strip()))

def solution():
	for _ in range(int(input())):
		(a, b) = scan()
		x = a * b
		y = a
		z = x + y
		if x == y or y == z or x == z or (x == y and y == z):
			print('NO')
		else:
			print('YES')
			print(x, y, z)
solution()


import os, sys, math
from io import BytesIO, IOBase
ma = lambda : map(int, input().split(' '))

def main():
	for _ in range(int(input())):
		(a, b) = ma()
		if b == 1:
			print('NO')
			continue
		print('YES')
		if b == 2:
			print(a, 3 * a, 4 * a)
			continue
		print(a, (b - 1) * a, b * a)
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys
import os.path
from collections import *
import math
import bisect
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
t = int(input())
while t:
	t -= 1
	(a, b) = [int(x) for x in input().split()]
	if b == 1:
		print('NO')
	else:
		print('YES')
		print(a * 1, a * b, a * (b + 1))


for ttt in range(int(input())):
	(a, b) = map(int, input().split())
	if b != 1:
		print('YES')
		print(a, 2 * a * b - a, 2 * a * b)
	else:
		print('NO')