//I wrote this code 4 u today
#include <bits/stdc++.h>

template<class t> using vc = std::vector<t>;

#define nd node*
#define pnd pair<nd, nd>

//using namespace std;
typedef long long ll;

template<const ll MOD>
struct mod_mul : std::multiplies<const ll> {
    ll operator()(const ll a, const ll b) {
        return (a * b) % MOD;
    }
};


template<typename T>
inline void sort(T &a) {
    sort(a.begin(), a.end());
}

template<typename T>
inline void unique(T &a) {
    a.resize(unique(a.begin(), a.end()) - a.begin());
}

template<typename T>
inline void reverse(T &a) {
    reverse(a.begin(), a.end());
}

const ll INF = 9023372036854775808ll;
const ll MOD = 1000000007ll;

std::pair<int, int> q[4] = {{0,  1},
                            {1,  0},
                            {0,  -1},
                            {-1, 0}};

int a[3005][3005];
int max = 0;

int n, k;

int lz = 0;
bool hra = false;

bool ger(int i, int j, int dep = 0) {
//    if (dep > 6) return false;
    if (j == n) ++i, j = 0;
    if (i == n) {
        return false;
    }
    if (max < k) return false;
    if (max == k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) std::cout << (a[i][j] ? 'B' : 'R');
            std::cout << '\n';
        }
        return true;
    }
    int hru1 = 0;
    for (auto [d1, d2]: q) {
        int i1 = i + d1, j1 = j + d2;
        if (i1 != -1 && j1 != -1 && i1 != n && j1 != n) hru1 += a[i][j] != a[i1][j1];
    }
    a[i][j] ^= 1;
    int hru2 = 0;
    for (auto [d1, d2]: q) {
        int i1 = i + d1, j1 = j + d2;
        if (i1 != -1 && j1 != -1 && i1 != n && j1 != n) hru2 += a[i][j] != a[i1][j1];
    }
    a[i][j] ^= 1;
    if (hru2 < hru1) {
        max += hru2 - hru1;
        a[i][j] ^= 1;
        if (ger(i, j + 1, dep + 1)) return true;
        a[i][j] ^= 1;
        max -= hru2 - hru1;
        if (ger(i, j + 1, dep + 1)) return true;
    } else {
        if (ger(i, j + 1, dep + 1)) return true;
        a[i][j] ^= 1;
        max += hru2 - hru1;
        if (ger(i, j + 1, dep + 1)) return true;
        a[i][j] ^= 1;
        max -= hru2 - hru1;
    }
    return false;
}

vc<std::array<int, 3>> x;
bool da[3005 * 3005 * 2];

int cnt = 0;
int sui = 0;

bool gen(int i = 0) {
    if (cnt == k) {
        for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) a[i][j] = 0;
        for (int i = 0; i < x.size(); ++i) if (da[i]) a[x[i][1]][x[i][2]] = 1;
        for (int i = 0; i < n; ++i) {
            std::string s;
            for (int j = 0; j < n; ++j) s.push_back(a[i][j] ? 'R' : 'B');
            std::cout << s << '\n';
        }
        return true;
    }
    if (cnt > k) return false;
    if (i == x.size()) {
        return false;
    }
    da[i] = 1;
    cnt += x[i][0];
    if (gen(i + 1)) return true;
    da[i] = 0;
    cnt -= x[i][0];
    if (gen(i + 1)) return true;
    return false;
}

bool heh(int cnt) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            a[i][j] = 0;
            if ((i + j) % 2 && cnt) {
                --cnt;
                a[i][j] = 1;
            }
        }
    }
    max = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            max += (j + 1 != n && a[i][j] != a[i][j + 1]) + (i + 1 != n && a[i][j] != a[i + 1][j]);
        }
    }
    return max >= k;
}

int main() {
    std::cin.tie(nullptr)->ios_base::sync_with_stdio(false);
    int t;
    std::cin >> t;
    while (t--) {
        std::cin >> n >> k;
//    for (n = 1; n <= 100; ++n) {
//        for (k = 1; k <= 100; ++k) {
//            n = 4, k = 3;
//        n = 5, k =35;
        if (n <= 3) {

            int hex = 0;
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    a[i][j] = 0;
                    if (max < k && (i + j) % 2) {
                        a[i][j] = 1;
                    }
                    hex += i != n - 1;
                    hex += j != n - 1;
                }
            }
            int lo = -1, hi = n * n + 5;
            while (hi - lo > 1) {
                int mi = (lo + hi) / 2;
                if (heh(mi)) hi = mi;
                else lo = mi;
            }
            hi += 3;
            hi = std::min(hi, n * n / 2);
            heh(hi);
//        std::cout << max << '\n';
            if (k > hex || k == hex - 1 || k == 1) {
                std::cout << "Impossible\n";
//            gen(0, 0);
            } else {
                std::cout << "Possible\n";
                assert(ger(0, 0));
            }
            continue;
        }
        int hex = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                hex += i != n - 1;
                hex += j != n - 1;
                a[i][j] = 0;
            }
        }

        if (k > hex || k == hex - 1 || k == 1) {
            std::cout << "Impossible\n";
//            gen(0, 0);
        } else {
            std::cout << "Possible\n";
            x.clear();
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    if ((i + j + 1) % 2) {
                        if (i % (n - 1) == 0 && j % (n - 1) == 0) x.push_back({2, i, j});
                        else if (i % (n - 1) == 0 || j % (n - 1) == 0) x.push_back({3, i, j});
                        else x.push_back({4, i, j});
                    }
                }
            }
            cnt = 0;
            std::sort(x.begin(), x.end());
            std::reverse(x.begin(), x.end());
            vc<int> q(5);
            for (auto [c, i, j]: x) q[c]++;
            for (auto [c, i, j]: x) {
//                    ->5;
                if (c == 3 && q[c] == 1 && (k % 3 == cnt % 3)) continue;
                if (c + cnt <= k && k - (c + cnt) != 1) {
                    a[i][j] = 1;
                    cnt += c;
                    --q[c];
                }
            }
                if (k != cnt) {
                    std::cout << n << ' ' << k << '\n';
                }
            assert(k == cnt);
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) std::cout << (a[i][j] ? 'B' : 'R');
                std::cout << '\n';
            }
        }
//
//        }
//    }

    }
}