#include <bits/stdc++.h>


using namespace std;


using ll = long long;

#define rep(i, n) for(int i = 0; i < (n); i += 1)
#define rng(i, start, end, step) for(int i = start; i < end; i += step)
#define len(a) ((int)(a).size())


mt19937 rnd(234);
const ll mod = 998244353;

ll bin_pow(ll x, ll n) {
    ll rs = 1;
    for (ll i = 1, a = x; i <= n; i *= 2, a = a * a % mod)
        if (n & i) rs = rs * a % mod;
    return rs;
}

ll inv(ll x) {
    return bin_pow(x, mod - 2);
}

namespace fft {
    int mxpw;
    int mxn;
    ll w;

    void build_w() {
        ll phi = mod - 1;
        ll f = phi;
        vector<ll> p;
        for (ll i = 2; i * i <= f; i += 1) {
            if (f % i == 0) {
                p.push_back(i);
                while (f % i == 0) {
                    f /= i;
                }
            }
        }
        if (f > 1) {
            p.push_back(f);
        }
        for (int i = 1; i < mod; i += 1) {
            bool ok = true;
            for (auto q : p) {
                if (bin_pow(i, phi / q) == 1) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                w = bin_pow(i, phi / (1 << mxpw));
                break;
            }
        }
    }

    vector<ll> rvx;

    void build_rvx(int n) {
        rvx.resize(n + 1);
        for (int i = 1; i <= n; i += 1) {
            rvx[i] = inv(i);
        }
    }

    vector<ll> rvi, wpws;

    void build(int _mxpw) {
        mxpw = _mxpw;
        mxn = (1 << mxpw);
        build_w();
        int n = (1 << mxpw);
        rvi.resize(n);
        rvi[0] = 0;
        for (int i = 1; i < n; i += 1) {
            rvi[i] = (rvi[i >> 1] >> 1);
            if (i & 1) {
                rvi[i] += (1 << (mxpw - 1));
            }
        }
        wpws.resize(n + 1);
        wpws[0] = 1;
        for (int i = 1; i <= n; i += 1) {
            wpws[i] = (wpws[i - 1] * w) % mod;
        }
        build_rvx(mxn);
    }

    void fft(vector<ll>& a, int nk) {
        int n = (1 << nk);
        for (int i = 0; i < n; i += 1) {
            int mrv = (rvi[i] >> (mxpw - nk));
            if (mrv < i) {
                swap(a[mrv], a[i]);
            }
        }
        for (int ln = 1; ln < n; ln *= 2) {
            int ln2 = ln + ln;
            for (int i = 0; i < n; i += ln2) {
                for (int j = 0; j < ln; j += 1) {
                    ll mw = wpws[mxn / ln2 * j];
                    int u = i + j;
                    int v = u + ln;
                    ll y = a[v] * mw % mod;
                    a[v] = a[u] - y;
                    if (a[v] < 0) {
                        a[v] += mod;
                    }
                    a[u] += y;
                    if (a[u] >= mod) {
                        a[u] -= mod;
                    }
                }
            }
        }
    }

    void rev_fft(vector<ll>& a, int nk) {
        int n = (1 << nk);
        fft(a, nk);
        ll rvn = inv(n);
        reverse(a.begin() + 1, a.end());
        for (int i = 0; i < n; i += 1) {
            a[i] = (a[i] * rvn) % mod;
        }
    }

    vector<ll> square(vector<ll> a) {
        int nk = 0;
        while ((1 << nk) < (int)a.size() + (int)a.size() - 1) {
            nk += 1;
        }
        int n = (1 << nk);
        a.resize(n, 0);
        fft(a, nk);
        for (int i = 0; i < n; i += 1) {
            a[i] = (a[i] * a[i]) % mod;
        }
        rev_fft(a, nk);
        while (!a.empty() && a.back() == 0) {
            a.pop_back();
        }
        return a;
    }

    vector<ll> mul(vector<ll> a, vector<ll> b) {
        int nk = 0;
        while ((1 << nk) < (int)a.size() + (int)b.size() - 1) {
            nk += 1;
        }
        int n = (1 << nk);
        a.resize(n, 0);
        b.resize(n, 0);
        fft(a, nk);
        fft(b, nk);
        for (int i = 0; i < n; i += 1) {
            a[i] = (a[i] * b[i]) % mod;
        }
        rev_fft(a, nk);
        while (!a.empty() && a.back() == 0) {
            a.pop_back();
        }
        return a;
    }

    void add_inplace(vector<ll>& a, const vector<ll>& b, ll k = 1) {
        a.resize(max(a.size(), b.size()), 0);
        for (int i = 0; i < (int)b.size(); i += 1) {
            a[i] = (a[i] + b[i] * k) % mod;
        }
    }

    vector<ll> add(vector<ll> a, const vector<ll>& b, ll k = 1) {
        a.resize(max(a.size(), b.size()), 0);
        for (int i = 0; i < (int)b.size(); i += 1) {
            a[i] = (a[i] + b[i] * k) % mod;
        }
        return a;
    }

    vector<ll> sub(vector<ll> a, const vector<ll>& b, ll k = 1) {
        a.resize(max(a.size(), b.size()), 0);
        for (int i = 0; i < (int)b.size(); i += 1) {
            a[i] = (a[i] + mod - b[i] * k % mod) % mod;
        }
        return a;
    }

    vector<ll> replace_x_slow(vector<ll>& a, const vector<ll>& b) {
        vector<ll> rs = {};
        vector<ll> bpw = { 1 };
        for (int i = 0; i < (int)a.size(); i += 1) {
            if (i > 0) {
                bpw = mul(bpw, b);
            }
            add_inplace(rs, bpw, a[i]);
        }
        return rs;
    }

    vector<ll> replace_x(vector<ll>& a, const vector<ll>& b) {
        vector<ll> rs = {};
        vector<ll> bpw = b;
        int n = a.size();
        vector<vector<ll>> d(n);
        for (int i = 0; i < n; i += 1) {
            d[i] = { a[i] };
        }
        while (n > 1) {
            int m = (n + 1) / 2;
            vector<vector<ll>> nd(m);
            for (int i = 0; i < n; i += 1) {
                if (i % 2 == 0) {
                    nd[i / 2] = d[i];
                } else {
                    add_inplace(nd[i / 2], mul(d[i], bpw));
                }
            }
            n = m;
            d.swap(nd);
            if (n != 1) {
                bpw = square(bpw);
            }
        }
        return d[0];
    }

    vector<ll> shift_x(vector<ll> a, ll t) {
        if (a.empty()) {
            return {};
        }
        int n = (int)a.size() - 1;
        vector<ll> f(n + 1), rf(n + 1);
        f[0] = rf[0] = 1;
        for (int i = 1; i <= n; i += 1) {
            f[i] = (f[i - 1] * i) % mod;
            rf[i] = inv(f[i]);
        }
        vector<ll> b(n + 1), c(n + 1);
        ll tpw = 1;
        for (int i = 0; i <= n; i += 1) {
            b[i] = (a[i] * tpw % mod * f[i] % mod);
            tpw = (tpw * t) % mod;
        }
        for (int i = 0; i <= n; i += 1) {
            c[n - i] = rf[i];
        }
        a = mul(b, c);
        vector<ll> d(n + 1);
        ll rvt = inv(t);
        ll rvt_pw = 1;
        for (int i = 0; i <= n; i += 1) {
            d[i] = rvt_pw * rf[i] % mod * a[i + n] % mod;
            rvt_pw = (rvt_pw * rvt) % mod;
        }
        return d;
    }

    vector<ll> rev_polynom(const vector<ll>& a, int n) {
        int sz = a.size();
        vector<ll> b = { inv(a[0]) };
        int m = 1;
        int mk = 0;
        while (m < n) {
            int m2 = m + m;
            int m4 = m2 + m2;
            b.resize(m4);
            fft(b, mk + 2);
            vector<ll> nb(m4);
            for (int i = 0; i < sz && i < m2; i += 1) {
                nb[i] = a[i];
            }
            fft(nb, mk + 2);
            for (int i = 0; i < m4; i += 1) {
                nb[i] = (2 * b[i] - nb[i] * b[i] % mod * b[i]) % mod;
                if (nb[i] < 0) {
                    nb[i] += mod;
                }
            }
            rev_fft(nb, mk + 2);
            nb.resize(m2);
            b.swap(nb);
            m = m2;
            mk += 1;
        }
        b.resize(n);
        return b;
    }

    vector<ll> square_root(const vector<ll>& a, int n) {
        ll sz = a.size();
        ll rv2 = inv(2);
        vector<ll> b = { 1 };
        int m = 1;
        while (m < n) {
            ll m2 = m + m;
            vector<ll> rvb = rev_polynom(b, m2);
            vector<ll> ab(m2);
            for (int i = 0; i < m2 && i < sz; i += 1) {
                ab[i] = a[i];
            }
            ab = mul(ab, rvb);
            ab.resize(m2);
            b.resize(m2);
            for (int i = 0; i < m2; i += 1) {
                b[i] = (rv2 * ((b[i] + ab[i]) % mod)) % mod;
            }
            m = m2;
        }
        b.resize(n);
        return b;
    }

    vector<ll> derivative(vector<ll> a) {
        int n = a.size();
        if (n == 0) {
            return {};
        }
        for (int i = 0; i + 1 < n; i += 1) {
            a[i] = (a[i + 1] * (i + 1)) % mod;
        }
        a.resize(n - 1);
        return a;
    }

    vector<ll> integrate(vector<ll> a) {
        int n = a.size();
        a.resize(n + 1);
        for (int i = n; i > 0; i -= 1) {
            a[i] = (a[i - 1] * rvx[i]) % mod;
        }
        a[0] = 0;
        return a;
    }

    vector<ll> sin_polynomial(int n) {
        vector<ll> a(n, 0);
        ll fct = 1;
        for (int i = 0; i < n; i += 1) {
            if (i != 0) {
                fct = (fct * i) % mod;
            }
            if (i % 2 == 1) {
                int sign = 1;
                if ((i / 2) % 2 == 1) {
                    sign = -1;
                }
                a[i] = (mod + sign * inv(fct)) % mod;
            }
        }
        return a;
    }

    vector<ll> cos_polynomial(int n) {
        vector<ll> a(n, 0);
        ll fct = 1;
        for (int i = 0; i < n; i += 1) {
            if (i != 0) {
                fct = (fct * i) % mod;
            }
            if (i % 2 == 0) {
                int sign = 1;
                if ((i / 2) % 2 == 1) {
                    sign = -1;
                }
                a[i] = (mod + sign * inv(fct)) % mod;
            }
        }
        return a;
    }

    vector<ll> super_cos_polynomial(int n, int k) {
        vector<ll> a(n, 0);
        ll fct = 1;
        for (int i = 0; i < n; i += 1) {
            if (i != 0) {
                fct = (fct * i) % mod;
            }
            if (i % k == 0) {
                int sign = 1;
                if ((i / k) % 2 == 1) {
                    sign = -1;
                }
                a[i] = (mod + sign * inv(fct)) % mod;
            }
        }
        return a;
    }

    vector<ll> logarithm(const vector<ll>& a, int n) {
        if (n == 0) {
            return {};
        }
        vector<ll> b = integrate(mul(derivative(a), rev_polynom(a, n)));
        b.resize(n);
        return b;
    }

    vector<ll> exponent(const vector<ll>& a, int n) {
        vector<ll> b = { 1 };
        int m = 1;
        while (m < n) {
            int m2 = m + m;
            vector<ll> t = logarithm(b, m2);
            for (int i = 0; i < m2 && i < (int)a.size(); i += 1) {
                t[i] = (t[i] - a[i]);
                if (t[i] < 0) {
                    t[i] += mod;
                }
            }
            vector<ll> q = fft::mul(t, b);
            q.resize(m2);
            b.resize(m2);
            for (int i = 0; i < m2; i += 1) {
                b[i] -= q[i];
                if (b[i] < 0) {
                    b[i] += mod;
                }
            }
            m = m2;
        }
        b.resize(n);
        return b;
    }

    vector<ll> solve_differential(const vector<ll>& a, const vector<ll>& b, int n) {
        vector<ll> e = exponent(integrate(a), n);
        vector<ll> result = mul(e, integrate(mul(b, rev_polynom(e, n))));
        result.resize(n);
        return result;
    }

    vector<ll> pure_exponent(int n, ll k = 1) {
        if (n == 0) {
            return {};
        }
        k %= mod;
        if (k < 0) {
            k += mod;
        }
        vector<ll> rs(n);
        rs[0] = 1;
        ll rv_fct = 1;
        for (int i = 1; i < n; i += 1) {
            rv_fct = (rv_fct * rvx[i]) % mod * k % mod;
            rs[i] = rv_fct;
        }
        return rs;
    }
}  // namespace fft

vector<ll> get_flex(int step, int num_steps) {
    vector<ll> result(step * num_steps);
    rep(i, num_steps) result[i * step] = 1;
    return result;
}


vector<ll> get_dice(vector<ll> flex) {
    vector<ll> result;
    rep(i, len(flex)) {
        assert(flex[i] >= 0);
        rep(j, flex[i]) result.push_back(i);
    }
    return result;
}


void print_flex(ll n, ll m, ll a, ll b) {
    ll nm = n * m;
    assert(n % a == 0 and m % b == 0);
    auto first_dice = get_dice(fft::mul(get_flex(1, n / a), get_flex(1, b)));
    auto second_dice = get_dice(fft::mul(get_flex(b, m / b), get_flex(n / a, a)));
    cout << len(first_dice); for (auto x : first_dice) cout << " " << x + 1;
    cout << "\n";
    cout << len(second_dice); for (auto x : second_dice) cout << " " << x + 1;
    cout << "\n\n";
}


int32_t main() {
    fft::build(21);
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int t;
    cin >> t;
    rep(itr, t) {
        int n, m;
        cin >> n >> m;
        if (n > m) swap(n, m);
        ll nm = ll(n) * m;
        ll opt = 1;
        for (ll x = 1; x * x <= nm; x += 1) {
            if (nm % x != 0) continue;
            if (opt + nm / opt > x + nm / x) opt = x;
        }
        if (opt != n) {
            ll g = gcd(opt, n);
            ll a = n / g;
            ll b = opt / g;
            print_flex(n, m, a, b);
            continue;
        }
        ll g = gcd(n, m);
        ll frst = -1;
        for (ll i = 2; i <= g; i += 1) if (g % i == 0) { frst = i; break; }
        assert(g == 1 or frst != -1);
        if (frst != -1 and frst < m) {
            print_flex(n, m, frst, frst);
            continue;
        }
        vector<ll> biba(n, 1), boba(m, 1);
        ll a = -1, b = -1;
        for (ll i = 2; i < n; i += 1) if (n % i == 0 and gcd(n / i, i) == 1) {
            a = i; b = n / i; break;
        };
        if (a != -1) {
            vector<ll> p(a, 1), q(b, 1);
            vector<ll> diff = fft::mul(biba, fft::rev_polynom(p, n));
            diff = fft::mul(diff, fft::rev_polynom(q, n));
            diff.resize(n);
            while (!diff.empty() and diff.back() == 0) {
                diff.pop_back();
            }
            for (auto& x : diff) if (x > mod / 2) x -= mod;
            biba = fft::mul(biba, fft::rev_polynom(diff, n));
            biba.resize(n);
            boba = fft::mul(boba, diff);
            auto first_dice = get_dice(biba);
            auto second_dice = get_dice(boba);
            cout << len(first_dice); for (auto x : first_dice) cout << " " << x + 1;
            cout << "\n";
            cout << len(second_dice); for (auto x : second_dice) cout << " " << x + 1;
            cout << "\n\n";
            continue;
        }
        opt = -1;
        for (ll x = 1e6 - 1000; x * x <= nm; x += 1) {
            if (nm % x != 0) continue;
            if (x == n) continue;
            if (opt == -1 or opt + nm / opt > x + nm / x) opt = x;
        }
        if (opt != -1 and opt + nm / opt < 2 * n + m) {
            ll g = gcd(opt, n);
            ll a = n / g;
            ll b = opt / g;
            print_flex(n, m, a, b);
            continue;
        }
        cout << 2 * n; rep(i, n) cout << " " << i + 1 << " " << i + 1; cout << "\n";
        cout << m; rep(i, m) cout << " " << i + 1; cout << "\n";
        cout << "\n";
    }
    return 0;
}