#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// (1 - x^a)
void mul(vector<int> &fs, int a) {
  const int fsLen = fs.size();
  fs.resize(fsLen + a, 0);
  for (int i = fsLen; --i >= 0; ) fs[i + a] -= fs[i];
}
void div(vector<int> &fs, int a) {
  const int fsLen = fs.size();
  assert(fsLen >= a);
  fs.resize(fsLen - a, 0);
  for (int i = 0; i < fsLen - a; ++i) fs[i + a] += fs[i];
}

int N[2];
Int opt;
vector<int> ans[2];

vector<int> pss[2], dss[2];

void solve() {
  opt = 2 * N[0] + N[1];
  ans[0].assign(N[0], 2);
  ans[1].assign(N[1], 1);
  
  for (int s = 0; s < 2; ++s) {
    pss[s].clear();
    dss[s].clear();
    {
      int n = N[s];
      for (int p = 2; p * p <= n; ++p) if (n % p == 0) {
        pss[s].push_back(p);
        do { n /= p; } while (n % p == 0);
      }
      if (n > 1) pss[s].push_back(n);
    }
    for (int d = 1; d * d <= N[s]; ++d) if (N[s] % d == 0) {
      dss[s].push_back(d);
      if (d != N[s] / d) dss[s].push_back(N[s] / d);
    }
    sort(dss[s].begin(), dss[s].end());
  }
  
  /*
    (x^0 + x^1 + ... + x^(d-1)) (x^0 + x^d + ... + x^(n-d))
    = ((1 - x^d) / (1 - x)) ((1 - x^n) / (1 - x^d))
  */
  Int bound = N[0] + N[1];
  {
    int cs[2] = {-1, -1};
    int ds[2] = {-1, -1};
    for (int c0 = 1; c0 <= 2; ++c0) for (int c1 = 1; c0 * c1 <= 2; ++c1) {
      for (const int d0 : dss[0]) for (const int d1 : dss[1]) {
        const Int nn0 = 1LL * c0 * d0 * d1;
        const Int nn1 = 1LL * c1 * (N[0] / d0) * (N[1] / d1);
        chmin(bound, nn0 + nn1);
        if ((nn0 == N[0] && nn1 == N[1]) || (nn0 == N[1] && nn1 == N[0])) {
          if (d0 == 1 || d1 == 1) continue;
        }
        if (chmin(opt, nn0 + nn1)) {
          cs[0] = c0; cs[1] = c1;
          ds[0] = d0; ds[1] = d1;
        }
      }
    }
    if (~cs[0]) {
      for (int s = 0; s < 2; ++s) {
        ans[s] = {cs[s]};
      }
      for (int s = 0; s < 2; ++s) {
        mul(ans[0], ds[s]);
        div(ans[0], 1);
        mul(ans[1], N[s]);
        div(ans[1], ds[s]);
      }
    }
  }
  
  if (opt == bound) return;
  
  /*
    1 - x^n =: \prod[d|n] F[d](x)
    F[n](x) = \prod[d|n] (1 - x^d)^mu(n/d)
    F[1](1) = 0,  F[p^e](1) = p,  F[composite](1) = 1
    move  F[pq](x)
  */
  for (int r = 0; r < 2; ++r) {
    for (const int p : pss[r]) for (const int q : pss[r]) if (p < q) {
      vector<int> tmp[2];
      for (int s = 0; s < 2; ++s) {
        tmp[s] = {1};
        mul(tmp[s], N[s]);
        div(tmp[s], 1);
      }
      mul(tmp[r ^ 1], 1);
      mul(tmp[r ^ 1], p * q);
      div(tmp[r ^ 1], q);
      div(tmp[r ^ 1], p);
      mul(tmp[r], p);
      mul(tmp[r], q);
      div(tmp[r], p * q);
      div(tmp[r], 1);
      bool ok = true;
      for (int s = 0; s < 2; ++s) {
        for (int i = 0; i < (int)tmp[s].size(); ++i) {
          ok = ok && (tmp[s][i] >= 0);
        }
      }
      for (int s = 0; s < 2; ++s) {
        for (int ss = 0; ss < 2; ++ss) {
          ok = ok && (tmp[s] != vector<int>(N[ss], 1));
        }
      }
// cerr<<p<<" "<<q<<" "<<tmp[0]<<" "<<tmp[1]<<endl;
      if (ok) {
        opt = N[0] + N[1];
        for (int s = 0; s < 2; ++s) {
          ans[s] = tmp[s];
        }
        return;
      }
    }
  }
  
  // TODO: proof
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    if (caseId > 1) puts("");
    
    scanf("%d%d", &N[0], &N[1]);
    
    if (N[0] > N[1]) swap(N[0], N[1]);
    solve();
    
#ifdef LOCAL
cerr<<COLOR("33")<<N[0]<<" "<<N[1]<<": "<<opt<<COLOR()<<endl;
#endif
    for (int s = 0; s < 2; ++s) {
      for (int i = 0; i < (int)ans[s].size(); ++i) {
        assert(ans[s][i] >= 0);
      }
    }
    for (int s = 0; s < 2; ++s) {
      int sum = 0;
      for (int i = 0; i < (int)ans[s].size(); ++i) {
        sum += ans[s][i];
      }
      printf("%d", sum);
      for (int i = 0; i < (int)ans[s].size(); ++i) {
        for (int j = 0; j < ans[s][i]; ++j) {
          printf(" %d", i + 1);
        }
      }
      puts("");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}