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.
//package com.company;

import java.awt.image.AreaAveragingScaleFilter;
import java.io.*;
import java.math.BigInteger;
import java.sql.SQLOutput;
import java.text.DecimalFormat;
import java.util.*;

public class Main
{
    public static void main(String[] args) throws IOException {
        OutputStream outputStream = System.out;
        FastReader in = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        PROBLEM solver = new PROBLEM();
        int t=1;
        t = in.nextInt();
        for(int i=0;i<t;i++){
            solver.solve(in, out);
        }
        out.close();
    }

    static class PROBLEM
    {
        public void solve(FastReader in,PrintWriter out) {

            long a = in.nextLong(), b = in.nextLong();

            if(b == 1) out.println("NO");
            else{
                long g = (a*b)*2;
                long x = (b+1)*a;
                long y = (b-1)*a;

                out.println("YES");

                out.println(x + " " + y + " " + g);
            }



        }
    }

    static char setOF(char[][] s){

        char c = s[0][0];
        if(s[0][0] != '_'){
            if(s[0][1] == s[0][0]){
                if(s[0][2] == s[0][1]){
                    return c;
                }
            }
            if(s[1][0] == c){
                if(s[2][0] == c){
                    return c;
                }
            }
            if(s[1][1] == c){
                if(s[2][2] == c){
                    return c;
                }
            }
        }

        if(s[0][1] != '_'){
            c = s[0][1];
            if(s[1][1] == c) {
                if (s[2][1] == c) {
                    return c;
                }
            }
        }

        if(s[0][2] != '_'){
            c = s[0][2];
            if(s[1][2] == c) {
                if (s[2][2] == c) {
                    return c;
                }
            }
            if(s[1][1] == c){
                if(s[2][0] == c){
                    return c;
                }
            }
        }

        if(s[1][0] != '_'){
            c = s[1][0];
            if(s[1][1] == c){
                if(s[1][2] == c){
                    return c;
                }
            }
        }

        if(s[2][0] != '_'){
            c = s[2][0];
            if(s[2][1] == c){
                if(s[2][2] == c){
                    return c;
                }
            }
        }
        return c;
    }

    static int isSet(char[][] s){

        int sets = 0;

        char c = s[0][0];
        if(s[0][0] != '_'){
            if(s[0][1] == s[0][0]){
                if(s[0][2] == s[0][1]){
                    sets++;
                }
            }
            if(s[1][0] == c){
                if(s[2][0] == c){
                    sets++;
                }
            }
            if(s[1][1] == c){
                if(s[2][2] == c){
                    sets++;
                }
            }
        }

        if(s[0][1] != '_'){
            c = s[0][1];
            if(s[1][1] == c) {
                if (s[2][1] == c) {
                    sets++;
                }
            }
        }

        if(s[0][2] != '_'){
            c = s[0][2];
            if(s[1][2] == c) {
                if (s[2][2] == c) {
                    sets++;
                }
            }
            if(s[1][1] == c){
                if(s[2][0] == c){
                    sets++;
                }
            }
        }

        if(s[1][0] != '_'){
            c = s[1][0];
            if(s[1][1] == c){
                if(s[1][2] == c){
                    sets++;
                }
            }
        }

        if(s[2][0] != '_'){
            c = s[2][0];
            if(s[2][1] == c){
                if(s[2][2] == c){
                    sets++;
                }
            }
        }
        return  sets;
    }

    static long gcd(long a, long b){
        if(b == 0) return a;
        return gcd(b, a%b);
    }

    static boolean isSquare(double a){
        boolean isSq = false;
        double b = Math.sqrt(a);
        double c = Math.sqrt(a) - Math.floor(b);

        if(c == 0) isSq = true;

        return isSq;
    }

    static int power(int x, int y, int p)
    {
        int res = 1; // Initialize result

        x = x % p; // Update x if it is more than or
        // equal to p

        if (x == 0)
            return 0; // In case x is divisible by p;

        while (y > 0)
        {
            // If y is odd, multiply x with result
            if ((y & 1) != 0)
                res = (res * x) % p;

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x%p * x%p) % p;
        }
        return res;
    }
    static int exponentMod(int A,
                           int B, int C)
    {

        // Base cases
        if (A == 0)
            return 0;
        if (B == 0)
            return 1;

        // If B is even
        long y;
        if (B % 2 == 0)
        {
            y = exponentMod(A, B / 2, C);
            y = (y * y) % C;
        }

        // If B is odd
        else
        {
            y = A % C;
            y = (y * exponentMod(A, B - 1,
                    C) % C) % C;
        }

        return (int)((y + C) % C);
    }

    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }

        public int hashCode() {
            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
        }

        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Pair<U, V> p = (Pair<U, V>) o;
            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
        }

        public int compareTo(Pair<U, V> b) {
            int cmpU = x.compareTo(b.x);
            return cmpU != 0 ? cmpU : y.compareTo(b.y);
        }

        public String toString() {
            return String.format("(%s, %s)", x.toString(), y.toString());
        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        char nextChar() {
            return next().charAt(0);
        }

        boolean nextBoolean() {
            return !(nextInt() == 0);
        }
        // boolean nextBoolean(){return Boolean.parseBoolean(next());}

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }

    //private static long binaryExpo(long )

    private static int[] mergeSort(int[] array){

        if(array.length <= 1){
            return array;
        }

        int midpoint = array.length / 2;

        int[] left = new int[midpoint];
        int[] right;

        if(array.length % 2 == 0){
            right = new int[midpoint];
        }else{
            right = new int[midpoint + 1];
        }

        for (int i = 0; i < left.length; i++) {
            left[i] = array[i];
        }

        for (int i = 0; i < right.length; i++) {
            right[i] = array[i + midpoint];
        }

        int[] result = new int[array.length];

        left = mergeSort(left);
        right = mergeSort(right);

        result = merge(left, right);

        return result;
    }

    private static int[] merge(int[] left, int[] right){

        int[] result = new int[left.length + right.length];
        int leftPointer = 0, rightPointer = 0, resultPointer = 0;

        while(leftPointer < left.length || rightPointer < right.length){

            if(leftPointer < left.length && rightPointer < right.length){

                if(left[leftPointer] < right[rightPointer]){
                    result[resultPointer++] = left[leftPointer++];
                }else{
                    result[resultPointer++] = right[rightPointer++];
                }
            }else if(leftPointer < left.length){
                result[resultPointer++] = left[leftPointer++];
            }else{
                result[resultPointer++] = right[rightPointer++];
            }
        }
        return result;
    }
}
