#pragma GCC optimize("O2")
#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <compare>
#include <complex>
#include <concepts>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numbers>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ranges>
#include <set>
#include <span>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <variant>

//#define int ll
#define INT128_MAX (__int128)(((unsigned __int128) 1 << ((sizeof(__int128) * __CHAR_BIT__) - 1)) - 1)
#define INT128_MIN (-INT128_MAX - 1)

namespace R = std::ranges;
namespace V = std::views;

using namespace std;

using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using tiii = tuple<int, int, int>;
using ldb = long double;
//#define double ldb

template<class T>
ostream& operator<<(ostream& os, const pair<T, T> pr) {
  return os << pr.first << ' ' << pr.second;
}
template<class T, size_t N>
ostream& operator<<(ostream& os, const array<T, N> &arr) {
  for(const T &X : arr)
    os << X << ' ';
  return os;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T> &vec) {
  for(const T &X : vec)
    os << X << ' ';
  return os;
}

signed main() {
  ios::sync_with_stdio(false), cin.tie(NULL);

  map<int, int> sol3;
  for(int mask = 0; mask < (1 << 9); mask++) {
    auto g = [&](int i, int j) { return mask >> (i * 3 + j) & 1; };
    int cnt = 0;
    for(int i = 0; i < 2; i++)
      for(int j = 0; j < 3; j++)
        cnt += g(i, j) != g(i + 1, j);
    for(int i = 0; i < 3; i++)
      for(int j = 0; j < 2; j++)
        cnt += g(i, j) != g(i, j + 1);
    sol3[cnt] = mask;
  }

  int t; cin >> t;
  while(t--) {
    int n, k; cin >> n >> k;

    //int kk = k;

    if (k == 1 or k == 2 * n * (n - 1) - 1) {
      cout << "Impossible\n";
      continue;
    }

    vector ans(n, string(n, 'B'));
    if (n == 2) {
      if (k == 2)
        ans[0][0] = 'R';
      else if (k == 4)
        ans[0][0] = ans[1][1] = 'R';
    } else if (n == 3) {
      int mask = sol3[k];
      for(int i = 0; i < 3; i++)
        for(int j = 0; j < 3; j++)
          ans[i][j] = (mask >> (i * 3 + j) & 1) ? 'R' : 'B';
    } else {
      auto out = [&](int i, int j) { return i < 0 or i >= n or j < 0 or j >= n; };
      const array<int, 4> di = {0, 0, -1, 1}, dj = {1, -1, 0, 0};
      vector<vector<array<int, 2>>> slot(5);
      for(int i = 0; i < n; i++) {
        for(int j = i & 1; j < n; j += 2) {
          int w = 0;
          for(int k = 0; k < 4; k++)
            w += !out(i + di[k], j + dj[k]);
          slot[w].push_back({i, j});
        }
      }

      while(k) {
        if (k >= 6) {
          int w;
          if (!slot[4].empty())
            w = 4;
          else if (ssize(slot[3]) > 1)
            w = 3;
          else
            w = 2;
          auto [i, j] = slot[w].back(); slot[w].pop_back();
          ans[i][j] = 'R', k -= w;
        } else if (k == 5) {
          ans[slot[2][0][0]][slot[2][0][1]] = ans[slot[3][0][0]][slot[3][0][1]] = 'R', k = 0;
        } else if (k == 4 and slot[4].empty()) {
          ans[slot[2][0][0]][slot[2][0][1]] = ans[slot[2][1][0]][slot[2][1][1]] = 'R', k = 0;
        } else {
          ans[slot[k][0][0]][slot[k][0][1]] = 'R', k = 0;
        }
      }
    }

    cout << "Possible\n";
    for(string s : ans)
      cout << s << '\n';
/*
    for(int i = 0; i < n; i++)
      for(int j = 0; j < n - 1; j++)
        kk -= ans[i][j] != ans[i][j + 1];
    for(int i = 0; i < n - 1; i++)
      for(int j = 0; j < n; j++)
        kk -= ans[i][j] != ans[i + 1][j];
    assert(kk == 0);
*/
  }

  return 0;
}