#include <bits/stdc++.h>
#define int long long
using namespace std;

string to_string(string s) { return s; }
template <typename T> string to_string(T v) {
  bool first = true;
  string res = "[";
  for (const auto &x : v) {
    if (!first)
      res += ", ";
    first = false;
    res += to_string(x);
  }
  res += "]";
  return res;
}

void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
  cout << ' ' << to_string(H);
  dbg_out(T...);
}

#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif

void solve() {
  int nbLig, nbCol;
  cin >> nbLig >> nbCol;
  if (nbLig * (nbLig + 1) / 2 % 2 and nbCol * (nbCol + 1) / 2 % 2) {
    cout << "No\n";
    return;
  }
  int want = nbLig * (nbLig + 1) / 2 * nbCol * (nbCol + 1) / 2;
  want /= 2;

  auto check = [&](vector<vector<int>> mat) {
    int cntPure = 0;
    for (int debLig = 0; debLig < nbLig; ++debLig)
      for (int finLig = debLig + 1; finLig <= nbLig; ++finLig) {
        for (int debCol = 0; debCol < nbCol; ++debCol) {
          bool ok = true;
          for (int finCol = debCol + 1; finCol <= nbCol; ++finCol) {
            for (int lig = debLig; lig < finLig; ++lig)
              ok &= mat[lig][finCol - 1] == mat[debLig][debCol];
            cntPure += ok;
            if (!ok)
              break;
          }
        }
      }
    if (cntPure == want)
      return true;
    return false;
  };

  auto f = [&](int x) { return x * (x + 1) / 2; };

  auto transpose = [&](vector<vector<int>> mat) {
    int N = mat.size(), M = mat[0].size();
    vector<vector<int>> ret(M, vector<int>(N));
    for (int lig = 0; lig < N; ++lig)
      for (int col = 0; col < M; ++col)
        ret[col][lig] = mat[lig][col];
    return ret;
  };

  auto fromDecomp = [&](vector<int> &decomposition, int width) {
    vector<vector<int>> ret;
    for (int i = 0; i < (int)decomposition.size(); ++i)
      for (int j = 0; j < decomposition[i]; ++j)
        ret.emplace_back(width, i % 2);
    return ret;
  };

  vector<vector<int>> sol;

  if (nbLig * (nbLig + 1) / 2 % 2 == 0) {
    int grilleRestant = nbLig * (nbLig + 1) / 4;
    int sumRestant = nbLig;
    vector<int> decomposition;
    while (sumRestant > 0) {
      dbg(sumRestant, grilleRestant, decomposition);
      int from = min(sumRestant, 2 * (int)sqrt(grilleRestant));
      while (grilleRestant - f(from) < sumRestant - from)
        --from;
      assert(from > 0);
      decomposition.push_back(from);
      sumRestant -= from;
      grilleRestant -= f(from);
    }
    dbg(sumRestant, grilleRestant, decomposition);
    assert(grilleRestant == 0 and sumRestant == 0);
    sol = fromDecomp(decomposition, nbCol);
  } else {
    int grilleRestant = nbCol * (nbCol + 1) / 4;
    int sumRestant = nbCol;
    vector<int> decomposition;
    while (sumRestant > 0) {
      int from = min(sumRestant, 2 * (int)sqrt(grilleRestant));
      while (grilleRestant - f(from) < sumRestant - from)
        --from;
      decomposition.push_back(from);
      sumRestant -= from;
      grilleRestant -= f(from);
    }
    dbg(sumRestant, grilleRestant, decomposition);
    assert(grilleRestant == 0 and sumRestant == 0);
    sol = transpose(fromDecomp(decomposition, nbLig));
  }
  cout << "Yes\n";
  for (int lig = 0; lig < nbLig; ++lig) {
    for (int col = 0; col < nbCol; ++col)
      cout << sol[lig][col] << ' ';
    cout << '\n';
  }
}

signed main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  int nbTests;
  cin >> nbTests;
  for (int iTest(0); iTest < nbTests; ++iTest)
    solve();
}