#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 <map>
#include <numeric>
#include <queue>
#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; }


constexpr int LIM_SMALL = 9;

void experiment() {
  /*
  for (int N = 1; N <= 5; ++N) {
    vector<int> brt(2*N*(N-1) + 1, 0);
    for (int p = 0; p < 1 << (N*N); ++p) {
      int cnt = 0;
      for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) {
        if (x + 1 < N && (p >> (x*N+y) & 1) != (p >> ((x+1)*N+y) & 1)) ++cnt;
        if (y + 1 < N && (p >> (x*N+y) & 1) != (p >> (x*N+(y+1)) & 1)) ++cnt;
      }
      brt[cnt] = 1;
    }
    if (N <= 10) {
      cerr << N << ": ";
      for (int x = 0; x <= 2*N*(N-1); ++x) cerr << brt[x];
      cerr << endl;
    }
  }
  //*/
  for (int N = 1; N <= 100; ++N) {
    vector<int> can(2*N*(N-1) + 1, 0);
    for (int a = 1; a < N; ++a) for (int b = 1; b < N; ++b) {
      const int lim = (max(a - 2, 0) * max(b - 2, 0) + 1) / 2;
      for (int i = 0; i <= lim; ++i) {
        can[a + b + 4 * i] = 1;
      }
    }
    for (int x = 0; x <= 2*N*(N-1); ++x) if (can[x]) {
      can[2*N*(N-1) - x] = 1;
    }
    if (N <= 12) {
      cerr << N << ": ";
      for (int x = 0; x <= 2*N*(N-1); ++x) cerr << can[x];
      cerr << endl;
    }
    if (N > LIM_SMALL) {
      for (int x = 2; x <= 2*N*(N-1) - 2; ++x) {
        // assert(can[x]);
      }
    }
  }
}


int small[LIM_SMALL + 1][2*LIM_SMALL*(LIM_SMALL-1) + 1][LIM_SMALL + 1][LIM_SMALL + 1];

void pre() {
  for (int N = 1; N <= LIM_SMALL; ++N) {
    bitset<2*LIM_SMALL*(LIM_SMALL-1) + 1>
        dp[LIM_SMALL * LIM_SMALL + 1][1 << LIM_SMALL] = {};
    for (int p = 0; p < 1 << N; ++p) {
      dp[N * N][p][0] = true;
    }
    for (int z = N * N; --z >= 0; ) {
      const int x = z / N, y = z % N;
      for (int p = 0; p < 1 << N; ++p) {
        for (int a = 0; a < 2; ++a) {
          const int pp = (p & ~(1 << y)) | a << y;
          int d = 0;
          if (x > 0 && (p >> y & 1) != a) ++d;
          if (y > 0 && (p >> (y-1) & 1) != a) ++d;
          dp[z][p] |= dp[z + 1][pp] << d;
        }
      }
    }
    for (int K = 0; K <= 2*N*(N-1); ++K) {
      if (dp[0][0][K]) {
        int p = 0, k = K;
        for (int z = 0; z < N * N; ++z) {
          const int x = z / N, y = z % N;
          for (int a = 0; a < 2; ++a) {
            const int pp = (p & ~(1 << y)) | a << y;
            int d = 0;
            if (x > 0 && (p >> y & 1) != a) ++d;
            if (y > 0 && (p >> (y-1) & 1) != a) ++d;
            if (k >= d && dp[z + 1][pp][k - d]) {
              small[N][K][x][y] = a;
              p = pp;
              k -= d;
              goto found;
            }
          }
          assert(false);
         found:{}
        }
      } else {
        for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) {
          small[N][K][x][y] = -1;
        }
      }
    }
  }
}

int f[1010][1010];

void judge(int N, int K) {
  for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) {
    assert(f[x][y] == 0 || f[x][y] == 1);
  }
  int cnt = 0;
  for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) {
    if (x + 1 < N && f[x][y] != f[x + 1][y]) ++cnt;
    if (y + 1 < N && f[x][y] != f[x][y + 1]) ++cnt;
  }
  if (K != cnt) {
    cerr << "judge failed N = " << N << ", K = " << K << ", cnt = " << cnt << endl;
    for (int x = 0; x < N; ++x) {
      for (int y = 0; y < N; ++y) cerr << f[x][y];
      cerr << endl;
    }
  }
  assert(K == cnt);
}

bool solveDiff(int N, int K) {
  if (K == 0) {
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) f[x][y] = 0;
    return true;
  }
  for (int a = 1; a < N; ++a) for (int b = 1; b < N; ++b) {
    if (a + b <= K && (K - (a + b)) % 4 == 0) {
      const int lim = (max(a - 2, 0) * max(b - 2, 0) + 1) / 2;
      const int tar = (K - (a + b)) / 4;
      if (tar <= lim) {
        for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) f[x][y] = 0;
        for (int x = 0; x < a; ++x) for (int y = 0; y < b; ++y) f[x][y] = 1;
        int cnt = 0;
        for (int x = 1; x < a - 1; ++x) for (int y = 1; y < b - 1; ++y) if (!((x + y) & 1)) {
          if (cnt++ < tar) {
            f[x][y] = 0;
          }
        }
        return true;
      }
    }
  }
  return false;
}

bool solve(int N, int K) {
  if (N <= LIM_SMALL) {
    if (~small[N][K][0][0]) {
      for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) f[x][y] = small[N][K][x][y];
      return true;
    } else {
      return false;
    }
  } else if (solveDiff(N, K)) {
    return true;
  } else if (solveDiff(N, 2*N*(N-1) - K)) {
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) if ((x + y) & 1) f[x][y] ^= 1;
    return true;
  } else {
    return false;
  }
}

void stress() {
  for (int N = 1; N <= 50; ++N) {
    vector<int> can(2*N*(N-1) + 1, 0);
    for (int K = 0; K <= 2*N*(N-1); ++K) {
      const bool res = solve(N, K);
      if (res) {
        if (N <= 15) {
          cerr << N << " " << K << endl;
          for (int x = 0; x < N; ++x) {
            for (int y = 0; y < N; ++y) cerr << f[x][y];
            cerr << endl;
          }
        }
        can[K] = 1;
        judge(N, K);
      }
    }
    if (N <= 10) {
      cerr << N << ": ";
      for (int x = 0; x <= 2*N*(N-1); ++x) cerr << can[x];
      cerr << endl;
    }
    for (int x = 2; x <= 2*N*(N-1) - 2; ++x) {
      assert(can[x]);
    }
  }
}

int main() {
  pre();
  
  // experiment();
  // stress();
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    int N, K;
    scanf("%d%d", &N, &K);
    
    const bool res = solve(N, K);
    if (res) {
#ifdef LOCAL
judge(N,K);
#endif
      puts("Possible");
      for (int x = 0; x < N; ++x) {
        for (int y = 0; y < N; ++y) {
          putchar("BR"[f[x][y]]);
        }
        puts("");
      }
    } else {
      puts("Impossible");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}