#include <bits/stdc++.h>

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int q;
    cin >> q;

    while (q--) {
        int a, b; cin >> a >> b;
        if (b == 1) {
            cout << "NO" << endl;
        } else {
            cout << "YES" << endl;
            cout << a << ' ' << a * (long long)b << ' ' << a * (long long)(b + 1) << endl;
        }
    }
}

#include "bits/stdc++.h"

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int q;
    cin >> q;

    while (q--) {
        int n; cin >> n;
        int x = 1e9 + 7, pos = -1;
        for (int i = 0; i < n; ++i) {
            int a; cin >> a;
            if (a < x) x = a, pos = i;
        }
        cout << n - 1 << endl;
        for (int i = 0; i < n; ++i) {
            if (i == pos) continue;
            cout << pos + 1 << ' ' << i + 1 << ' ' << x << ' ' << x + abs(i - pos) << "\n";
        }
    }
}

#include "bits/stdc++.h"

using namespace std;

int ask(int t, int i, int j, int x) {
    cout << "? " << t << ' ' << i + 1 << ' ' << j + 1 << ' ' << x << endl;
    int val; cin >> val;
    if (val == -1) exit(0);
    return val;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int q;
    cin >> q;

    while (q--) {
        int n; cin >> n;
        vector<int> p(n, -1);
        for (int i = 1; i < n; i += 2) {
            int pos1 = i - 1, pos2 = i;
            int val = ask(1, pos1, pos2, n - 1);
            if (val == n - 1) {
                val = ask(1, pos2, pos1, n - 1);
                if (val == n) {
                    p[pos1] = val;
                    p[pos2] = ask(2, pos2, pos1, 1);
                    continue;
                }
            }
            int get = ask(1, pos1, pos2, val - 1);
            if (get == val) {
                p[pos2] = val;
                p[pos1] = ask(2, pos1, pos2, 1);
            }
            if (get == val - 1) {
                p[pos1] = val;
                p[pos2] = ask(2, pos2, pos1, 1);
            }
        }
        if (p.back() == -1) {
            vector<bool> us(n + 1);
            for (int i = 0; i < n - 1; ++i) {
                us[p[i]] = true;
            }
            for (int i = 1; i <= n; ++i) {
                if (!us[i]) {
                    assert(p[p.size() - 1] == -1);
                    p[p.size() - 1] = i;
                }
            }
        }
        cout << "! ";
        for (int i = 0; i < n; ++i) {
            cout << p[i] << ' ';
        } cout << endl;
    }
}

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 7;

struct edge {
    int v, u;
};

vector<pair<edge, edge>> operations;

int dp[N], answer = 0;

bool isDeleted[N];

vector<pair<int, int>> g[N];

void dfs(int v, int p = -1) {
    int sz = (int)g[v].size() - (p != -1);
    for (auto to : g[v]) {
        if (to.first == p) continue;
        dfs(to.first, v);
        if (dp[to.first]) {
            --sz; ++answer;
            isDeleted[to.second] = true;
        }
    }
    if (sz >= 2) {
        dp[v] = true;
        for (auto to : g[v]) {
            if (to.first == p) continue;
            if (sz <= 2) break;
            if (!dp[to.first]) {
                --sz; ++answer;
                isDeleted[to.second] = true;
            }
        }
    }
}

vector<pair<int, int>> bamboos;

bool used[N];

vector<int> leaves;

void dfs2(int v, int root) {
    used[v] = true;
    int numberOfChildren = 0;
    for (auto to : g[v]) {
        if (used[to.first] || isDeleted[to.second]) continue;
        ++numberOfChildren; dfs2(to.first, root);
    }
    if (v == root && numberOfChildren == 1) {
        leaves.push_back(v);
    } else if (!numberOfChildren) {
        leaves.push_back(v);
    }
}

void clear(int n) {
    answer = 0;
    for (int i = 0; i < n; ++i) {
        dp[i] = 0;
        g[i].clear();
        used[i] = isDeleted[i] = false;
    }
    bamboos.clear();
    operations.clear();
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int q;
    cin >> q;

    while (q--) {
        int n; cin >> n;

        for (int i = 0; i < n - 1; ++i) {
            int a, b; cin >> a >> b;
            --a; --b;
            g[a].push_back({b, i});
            g[b].push_back({a, i});
        }

        dfs(0);
        for (int i = 0; i < n; ++i) {
            if (!used[i]) {
                dfs2(i, i);
                assert((int)leaves.size() <= 2);
                if ((int)leaves.size() == 2) {
                    bamboos.push_back({leaves[0], leaves[1]});
                }
                if ((int)leaves.size() == 1) {
                    bamboos.push_back({leaves.back(), leaves.back()});
                }
                leaves.clear();
            }
        }

        vector<edge> deletedEdges, addedEdges;
        for (int v = 0; v < n; ++v) {
            for (auto to : g[v]) {
                if (isDeleted[to.second]) {
                    if (v < to.first) {
                        deletedEdges.push_back({v, to.first});
                    }
                }
            }
        }
        for (int i = 1; i < (int)bamboos.size(); ++i) {
            addedEdges.push_back({bamboos[i - 1].second, bamboos[i].first});
        }

        assert(answer == (int)deletedEdges.size());
        assert((int)deletedEdges.size() == (int)addedEdges.size());

        for (int i = 0; i < answer; ++i) {
            operations.push_back({deletedEdges[i], addedEdges[i]});
        }

        assert(answer == (int)operations.size());

        cout << answer << endl;
        for (pair<edge, edge> to : operations) {
            cout << to.first.v + 1 << ' ' << to.first.u + 1 << ' ';
            cout << to.second.v + 1 << ' ' << to.second.u + 1 << endl;
        }

        clear(n);
    }
}

#include "bits/stdc++.h"

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int q;
    cin >> q;

    while (q--) {
        int m, k; cin >> m >> k;

        pair<int, int> a[k];
        for (int i = 0; i < k; ++i) {
            cin >> a[i].first, a[i].second = i + 1;
        } sort(a, a + k, greater<pair<int, int>>());

        int mx = a[0].first;
        for (int n = 1; n <= m; ++n) {
            // mx <= n * ceil(n / 2)
            if (mx > n * (long long)((n + 1) / 2)) continue;
            // m <= n ^ 2 - floor(n / 2) ^ 2
            if (m > n * (long long)n - (n / 2) * (long long)(n / 2)) continue;

            // answer = n
            vector<pair<int, int>> x, y, z;
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    if ((i + j) % 2 == 1) {
                        if (i % 2 == 0) x.push_back({i, j});
                        else y.push_back({i, j});
                    } else {
                        if (i % 2 == 0) z.push_back({i, j});
                    }
                }
            }

            int ans[n][n];
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    ans[i][j] = 0;
                }
            }

            for (int i = 0; i < k; ++i) {
                vector<pair<int, int>> &cur = (x.empty() ? y : x);
                while (a[i].first && !cur.empty()) {
                    pair<int, int> pos = cur.back();
                    ans[pos.first][pos.second] = a[i].second;
                    cur.pop_back(); --a[i].first;
                }
                while(a[i].first--) {
                    assert((int)z.size() > 0);
                    pair<int, int> pos = z.back();
                    ans[pos.first][pos.second] = a[i].second;
                    z.pop_back();
                }
            }

            // print answer
            cout << n << endl;
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    cout << ans[i][j] << ' ';
                } cout << endl;
            }

            break;
        }
    }
}