#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;
        }
    }
}

#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;
        if(n <= 30){
            cout << "NO" << endl;
        }
        else{
            cout << "YES" << endl;
            if(n == 36 || n == 40 || n == 44){
                cout << 6 << ' ' << 10 << ' ' << 15 << ' ' << n - 31 << endl;
            }
            else{
                cout << 6 << ' ' << 10 << ' ' << 14 << ' ' << n - 30 << 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 = (n + 3) / 4;
        for (int i = 0; i < n - x; ++i) {
            cout << 9;
        }
        for (int i = 0; i < x; ++i) {
            cout << 8;
        }
        cout << endl;
    }
}

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 7;

vector < int > gr[N];

bool access = true;

int p[N], h[N], a[N], g[N];

void dfs(int v, int ancestor = -1) {
    a[v] = p[v];
    int sum_g = 0;
    for (int to : gr[v]) {
        if (to == ancestor) continue;
        dfs(to, v);
        sum_g += g[to];
        a[v] += a[to];
    }
    if ((a[v] + h[v]) % 2 == 0) {} // first
    else access = false;
    g[v] = (a[v] + h[v]) / 2;
    if (g[v] >= 0 && g[v] <= a[v]) {} // second
    else access = false;
    if (sum_g <= g[v]) {} // third
    else access = false;
}

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

    int q;
    cin >> q;

    while (q--) {
        int n, m; cin >> n >> m;
        for (int i = 0; i < n; ++i) cin >> p[i];
        for (int i = 0; i < n; ++i) cin >> h[i];
        for (int i = 0; i < n - 1; ++i) {
            int a, b; cin >> a >> b;
            --a, --b;
            gr[a].push_back(b);
            gr[b].push_back(a);
        }
        dfs(0);
        cout << (access ? "YES" : "NO") << endl;
        access = true;
        for (int i = 0; i < n; ++i) gr[i].clear();
    }
}

#include <bits/stdc++.h>
#define ll long long
#define all(a) a.begin(),a.end()

using namespace std;

vector <vector <int> > edge;
vector <ll> a;
vector <int> b, used;
vector <int> order[2];
ll ans;
inline void dfs (int v) {
    used[v] = 1;
    for (int to : edge[v]) {
        if (!used[to]) dfs(to);
    }
    ans += a[v];
    if (b[v] != -1 && a[v] > 0) {
        a[b[v]] += a[v];
    }
    if (a[v] > 0) {
        order[0].push_back(v);
    }
    else {
        order[1].push_back(v);
    }
}
inline void solve () {
    for (auto &i : edge) i.clear();
    edge.clear();
    a.clear();
    order[0].clear();
    order[1].clear();
    b.clear();
    used.clear();
    int n, x;
    cin >> n;
    edge.resize(n);
    a.resize(n);
    b.resize(n);
    for (auto &i : a) cin >> i;
    for (int i = 0; i < n; i++) {
        cin >> x;
        if (x != -1) {
            --x;
            edge[x].push_back(i);
        }
        b[i] = x;
    }
    ans = 0;
    used.assign(n, 0);
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            dfs(i);
        }
    }
    cout << ans << '\n';
    reverse(all(order[1]));
    for (auto &i : order[0]) cout << i + 1 << ' ';
    for (auto &i : order[1]) cout << i + 1 << ' ';
    cout << '\n';
}
main()
{
    ios::sync_with_stdio(0);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();
}

#include <bits/stdc++.h>

#define Vanya Unstoppable

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);
    
    int n;
    cin >> n;
    
    long long a[n];
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    
    set < int > s;
    for (int i = 0; i < n; ++i) {
        s.insert(i);
    }
    
    int b[n];
    vector < int > sz(n);
    for (int i = 0; i < n; ++i) {
        cin >> b[i]; --b[i];
        if (b[i] == -2) continue;
        ++sz[b[i]];
        if (sz[b[i]] == 1) {
            s.erase(b[i]);
        }
    }
    
    long long sum = 0;
    vector < int > ans[2];
    
    while (!s.empty()) {
        int v = *s.begin();
        s.erase(s.begin());
        int w = b[v];
        sum += a[v];
        if (a[v] >= 0) {
            if (w >= 0) {
                a[w] += a[v];
            }
            ans[0].push_back(v);
        } else {
            ans[1].push_back(v);
        }
        if (w >= 0) {
            --sz[w];
            if (sz[w] == 0) {
                s.insert(w);
            }
        }
    }
    
    cout << sum << endl;
    for (int to : ans[0]) cout << to + 1 << ' ';
    
    reverse(ans[1].begin(), ans[1].end());
    
    for (int to : ans[1]) cout << to + 1 << ' ';
    cout << endl;
}

#include <bits/stdc++.h>

#define pb push_back
#define x first
#define y second

using namespace std;

const int N = 1e5 + 10;
const double eps = 1e-9;

double xl[N], xr[N], y[N], pi = acos(-1), mn_x, mx_x;
int ind_l, ind_r;

double point_pr(double x, double y, double ctg) {
    return x - y * ctg;
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n;
    vector<pair<double, int> > q;
    vector<pair<double, pair<int, int> > > events, prom_left, prom_right;
    cin >> n;
    pair<double, double> mx, mn;
    mx = {-1.0, -1.0};
    mn = {2e9, 2e9};
    mn_x = 2e9;
    mx_x = -2e9;
    for(int i = 0; i < n; ++i) {
        cin >> xl[i] >> xr[i] >> y[i];

        if(xl[i] < mn_x) {
            mn_x = xl[i];
        }
        if(xr[i] > mx_x) {
            mx_x = xr[i];
        }

        if(mx.y < y[i]) {
            mx.y = y[i];
            mx.x = xl[i];
            ind_l = i;
        }
        else if(mx.y == y[i] && mx.x > xl[i]) {
            mx.y = y[i];
            mx.x = xl[i];
            ind_l = i;
        }

        if(mn.y > y[i]) {
            mn.y = y[i];
            mn.x = xl[i];
            ind_r = i;
        }
        else if(mn.y == y[i] && mn.x < xl[i]) {
            mn.y = y[i];
            mn.x = xl[i];
            ind_r = i;
        }
    }
    double a1, a2;
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < n; ++j) {
            if(y[i] > y[j]) {
                a1 = (xr[i] - xl[j]) / (y[i] - y[j]);
                a2 = (xl[i] - xr[j]) / (y[i] - y[j]);
                q.pb({a1, 1});
                q.pb({a2, 2});

                a1 = (xl[i] - xl[j]) / (y[i] - y[j]);
                a2 = (xr[i] - xr[j]) / (y[i] - y[j]);
                events.pb({a1, {i, j}});
                events.pb({a2, {-i - 1, j}});
            }
        }
    }

    if(q.empty()) {
        cout << fixed << setprecision(9) << mx_x - mn_x << endl;
        return 0;
    }

    sort(q.rbegin(), q.rend());
    int cnt = 0;
    double last = 0;
    for(auto i : q) {
        if(i.y == 2) {
            --cnt;
            if(!cnt) {
                events.pb({i.x, {-1e9, -1e9}});
            }
        }
        else {
            if(!cnt) {
                events.pb({i.x, {-1e9, -1e9}});
            }
            ++cnt;
        }
    }
    sort(events.rbegin(), events.rend());
    double ans = 1e18, ang;
    last = -1e18;
    for(auto i : events) {
        if(i.y.x == i.y.y) {
            unordered_set<int> s;
            vector<int> to_check;
            for(auto j : prom_left) {
                s.insert(j.y.x);
                if(j.y.x == ind_l) {
                    to_check.pb(j.y.y);
                }
            }
            prom_left.clear();
            for(auto j : to_check) {
                if(!s.count(j)) {
                    ind_l = j;
                    break;
                }
            }
            s.clear();
            to_check.clear();

            for(auto j : prom_right) {
                s.insert(j.y.y);
                if(j.y.y == ind_r) {
                    to_check.pb(-j.y.x - 1);
                }
            }
            prom_right.clear();
            for(auto j : to_check) {
                if(!s.count(j)) {
                    ind_r = j;
                    break;
                }
            }
            s.clear();
            to_check.clear();

            double res = point_pr(xr[ind_r], y[ind_r], i.x) - point_pr(xl[ind_l], y[ind_l], i.x);
            if(ans > res) {
                ans = res;
                ang = i.x;
            }
        }
        else if(i.y.x < 0) {
            if(abs(i.x - last) > eps) {
                unordered_set<int> s;
                vector<int> to_check;
                for(auto j : prom_right) {
                    s.insert(j.y.y);
                    if(j.y.y == ind_r) {
                        to_check.pb(-j.y.x - 1);
                    }
                }
                prom_right.clear();
                for(auto j : to_check) {
                    if(!s.count(j)) {
                        ind_r = j;
                        break;
                    }
                }
                s.clear();
                to_check.clear();
            }
            prom_right.pb(i);
        }
        else {
            if(abs(i.x - last) > eps) {
                unordered_set<int> s;
                vector<int> to_check;
                for(auto j : prom_left) {
                    s.insert(j.y.x);
                    if(j.y.x == ind_l) {
                        to_check.pb(j.y.y);
                    }
                }
                prom_left.clear();
                for(auto j : to_check) {
                    if(!s.count(j)) {
                        ind_l = j;
                        break;
                    }
                }
                s.clear();
                to_check.clear();
            }
            prom_left.pb(i);
        }
        last = i.x;
    }
    cout << fixed << setprecision(9) << ans << endl;
    return 0;
}