// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("Ofast,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
// #pragma GCC optimize("unroll-loops")

#include <stdio.h>
#include <bits/stdc++.h>

#ifdef PERVEEVM_LOCAL
    #define debug(x) std::cerr << (#x) << ":\t" << (x) << std::endl
#else
    #define debug(x) 238
#endif

#define fastIO std::ios_base::sync_with_stdio(false); std::cin.tie(0); std::cout.tie(0)
#define NAME "File"

using ll = long long;
using ld = long double;

#ifdef PERVEEVM_LOCAL
    std::mt19937 rnd(238);
#else
    std::mt19937 rnd(std::chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

template<typename T1, typename T2>
std::ostream& operator<<(std::ostream& out, const std::pair<T1, T2>& p) {
    out << "(" << p.first << ", " << p.second << ")";
    return out;
}

template<size_t index, typename T>
std::ostream& print_tuple(std::ostream& out, const T& t) {
    if constexpr (index == std::tuple_size<T>::value) {
        out << ")";
        return out;
    } else {
        if (index > 0) {
            out << ", ";
        } else {
            out << "(";
        }
        out << std::get<index>(t);
        return print_tuple<index + 1, T>(out, t);
    }
}

template<typename ...T>
std::ostream& operator<<(std::ostream& out, const std::tuple<T...>& t) {
    return print_tuple<0, std::tuple<T...>>(out, t);
}

template<typename Container, typename = decltype(std::begin(std::declval<Container>()))>
typename std::enable_if<!std::is_same<Container, std::string>::value, std::ostream&>::type
operator<<(std::ostream& out, const Container& container) {
    out << "{";
    for (auto it = container.begin(); it != container.end(); ++it) {
        if (it != container.begin()) {
            out << ", ";
        }
        out << *it;
    }
    out << "}";
    return out;
}

template<typename T>
bool smin(T& a, const T& b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<typename T>
bool smax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

const double PI = atan2(0.0, -1.0);
const int INF = 0x3f3f3f3f;
const ll LINF = (ll)2e18;
const int N = 1100;

int color[N][N];
bool changed[N][N];

bool solve(int n, int k, int c) {
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			changed[i][j] = false;
		}
	}

	int cur = 0;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (i + 1 < n && color[i][j] != color[i + 1][j]) {
				++cur;
			}
			if (j + 1 < n && color[i][j] != color[i][j + 1]) {
				++cur;
			}
		}
	}
	assert(cur >= k);

	int cnt4 = 0, cnt3 = 0, cnt2 = 0;
	int free4 = 0, free3 = 0, free2 = 0;

	auto isSide = [&](int coord) {
		return coord == 0 || coord == n - 1;
	};	

	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (color[i][j] != c) {
				continue;
			}

			if (isSide(i) && isSide(j)) {
				++free2;
			} else if (isSide(i) || isSide(j)) {
				++free3;
			} else {
				++free4;
			}
		}
	}

	int diff = cur - k;
	// debug(diff);
	for (int i = 1; i < n - 1; ++i) {
		for (int j = 1; j < n - 1; ++j) {
			if (color[i][j] != c) {
				continue;
			}
			if (diff - 4 >= 0) {
				color[i][j] ^= 1;
				diff -= 4;
				++cnt4;
				changed[i][j] = true;
			}
		}
	}

	for (int i = 1; i < n - 1; ++i) {
		if (color[0][i] == c && diff - 3 >= 0) {
			color[0][i] ^= 1;
			diff -= 3;
			++cnt3;
			changed[0][i] = true;
		}
		if (color[n - 1][i] == c && diff - 3 >= 0) {
			color[n - 1][i] ^= 1;
			diff -= 3;
			++cnt3;
			changed[n - 1][i] = true;
		}
		if (color[i][0] == c && diff - 3 >= 0) {
			color[i][0] ^= 1;
			diff -= 3;
			++cnt3;
			changed[i][0] = true;
		}
		if (color[i][n - 1] == c && diff - 3 >= 0) {
			color[i][n - 1] ^= 1;
			diff -= 3;
			++cnt3;
			changed[i][n - 1] = true;
		}
	}

	if (color[0][0] == c && diff - 2 >= 0) {
		color[0][0] ^= 1;
		diff -= 2;
		++cnt2;
		changed[0][0] = true;
	}
	if (color[0][n - 1] == c && diff - 2 >= 0) {
		color[0][n - 1] ^= 1;
		diff -= 2;
		++cnt2;
		changed[0][n - 1] = true;
	}
	if (color[n - 1][0] == c && diff - 2 >= 0) {
		color[n - 1][0] ^= 1;
		diff -= 2;
		++cnt2;
		changed[n - 1][0] = true;
	}
	if (color[n - 1][n - 1] == c && diff - 2 >= 0) {
		color[n - 1][n - 1] ^= 1;
		diff -= 2;
		++cnt2;
		changed[n - 1][n - 1] = true;
	}

	// std::cout << "diff = " << diff << std::endl;
	// debug(diff);
	// debug(cnt2);
	// debug(cnt3);
	// debug(cnt4);
	// debug(free2);
	// debug(free3);
	// debug(free4);
	if (diff != 0 && diff != 1) {
		return false;
	}
	assert(diff == 0 || diff == 1);
	if (diff == 0) {
		return true;
	}

	if (cnt2 > 0 && cnt3 < free3) {
		if (changed[0][0]) {
			color[0][0] ^= 1;
		} else if (changed[0][n - 1]) {
			color[0][n - 1] ^= 1;
		} else if (changed[n - 1][0]) {
			color[n - 1][0] ^= 1;
		} else if (changed[n - 1][n - 1]) {
			color[n - 1][n - 1] ^= 1;
		} else {
			throw;
		}

		bool fl = false;
		for (int i = 1; i < n - 1; ++i) {
			if (!changed[0][i] && color[0][i] == c) {
				color[0][i] ^= 1;
				fl = true;
				break;
			} else if (!changed[i][0] && color[0][i] == c) {
				color[i][0] ^= 1;
				fl = true;
				break;
			} else if (!changed[i][n - 1] && color[0][i] == c) {
				color[i][n - 1] ^= 1;
				fl = true;
				break;
			} else if (!changed[n - 1][i] && color[0][i] == c) {
				color[n - 1][i] ^= 1;
				fl = true;
				break;
			} else {
				continue;
			}
		}

		assert(fl);
		return true;
	}
	if (cnt3 > 0 && cnt4 < free4) {
		bool fl = false;
		for (int i = 1; i < n - 1; ++i) {
			if (changed[0][i]) {
				color[0][i] ^= 1;
				fl = true;
				break;
			} else if (changed[i][0]) {
				color[i][0] ^= 1;
				fl = true;
				break;
			} else if (changed[i][n - 1]) {
				color[i][n - 1] ^= 1;
				fl = true;
				break;
			} else if (changed[n - 1][i]) {
				color[n - 1][i] ^= 1;
				fl = true;
				break;
			} else {
				continue;
			}
		}

		assert(fl);

		for (int i = 1; i < n - 1; ++i) {
			for (int j = 1; j < n - 1; ++j) {
				if (!changed[i][j] && color[i][j] == c) {
					color[i][j] ^= 1;
					return true;
				}
			}
		}

		throw;
	}
	if (free2 - cnt2 >= 2 && cnt3 > 0) {
		bool fl = false;
		// for (int i = 0; i < n; ++i) {
		// 	for (int j = 0; j < n; ++j) {
		// 		std::cout << color[i][j];
		// 	}
		// 	std::cout << std::endl;
		// }

		for (int i = 1; i < n - 1; ++i) {
			if (changed[0][i]) {
				color[0][i] ^= 1;
				fl = true;
				// std::cout << 0 << ' ' << i << std::endl;
				break;
			} else if (changed[i][0]) {
				color[i][0] ^= 1;
				fl = true;
				// std::cout << i << ' ' << 0 << std::endl;
				break;
			} else if (changed[i][n - 1]) {
				color[i][n - 1] ^= 1;
				fl = true;
				// std::cout << i << ' ' << n - 1 << std::endl;
				break;
			} else if (changed[n - 1][i]) {
				color[n - 1][i] ^= 1;
				fl = true;
				// std::cout << n - 1 << ' ' << i << std::endl;
				break;
			} else {
				continue;
			}
		}

		// for (int i = 0; i < n; ++i) {
		// 	for (int j = 0; j < n; ++j) {
		// 		std::cout << color[i][j];
		// 	}
		// 	std::cout << std::endl;
		// }

		assert(fl);

		int cntChanged = 0;
		if (!changed[0][0] && color[0][0] == c && cntChanged < 2) {
			color[0][0] ^= 1;
			++cntChanged;
		}
		if (!changed[0][n - 1] && color[0][n - 1] == c && cntChanged < 2) {
			color[0][n - 1] ^= 1;
			++cntChanged;
		}
		if (!changed[n - 1][0] && color[n - 1][0] == c && cntChanged < 2) {
			color[n - 1][0] ^= 1;
			++cntChanged;
		}
		if (!changed[n - 1][n - 1] && color[n - 1][n - 1] == c && cntChanged < 2) {
			color[n - 1][n - 1] ^= 1;
			++cntChanged;
		}

		assert(cntChanged == 2);
		return true;
	}
	if (cnt4 > 0 && free3 - cnt3 >= 1 && free2 - cnt2 >= 1) {
		bool fl = false;
		for (int i = 1; i < n - 1; ++i) {
			for (int j = 1; j < n - 1; ++j) {
				if (changed[i][j] && !fl) {
					color[i][j] ^= 1;
					fl = true;
				}
			}
		}

		int cntChanged = 0;
		if (!changed[0][0] && color[0][0] == c && cntChanged < 1) {
			color[0][0] ^= 1;
			++cntChanged;
		}
		if (!changed[0][n - 1] && color[0][n - 1] == c && cntChanged < 1) {
			color[0][n - 1] ^= 1;
			++cntChanged;
		}
		if (!changed[n - 1][0] && color[n - 1][0] == c && cntChanged < 1) {
			color[n - 1][0] ^= 1;
			++cntChanged;
		}
		if (!changed[n - 1][n - 1] && color[n - 1][n - 1] == c && cntChanged < 1) {
			color[n - 1][n - 1] ^= 1;
			++cntChanged;
		}

		assert(cntChanged == 1);

		fl = false;
		for (int i = 1; i < n - 1; ++i) {
			if (!changed[0][i] && color[0][i] == c) {
				color[0][i] ^= 1;
				fl = true;
				break;
			} else if (!changed[i][0] && color[0][i] == c) {
				color[i][0] ^= 1;
				fl = true;
				break;
			} else if (!changed[i][n - 1] && color[0][i] == c) {
				color[i][n - 1] ^= 1;
				fl = true;
				break;
			} else if (!changed[n - 1][i] && color[0][i] == c) {
				color[n - 1][i] ^= 1;
				fl = true;
				break;
			} else {
				continue;
			}
		}
		assert(fl);

		return true;
	}

	return false;
}

void solve(int n, int k) {
	if (n == 3 && k == 5) {
		for (int i = 0; i < 3; ++i) {
			color[0][i] = 1;
			color[2][i] = 0;
		}
		color[1][0] = 0;
		color[1][1] = 1;
		color[1][2] = 0;

		printf("Possible\n");
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				if (color[i][j] == 0) {
					printf("R");
				} else {
					printf("B");
				}
			}
			printf("\n");
		}
		return;
	}
	if (n == 3 && k == 7) {
		color[0][0] = 0;
		color[0][1] = 1;
		color[0][2] = 0;
		for (int i = 0; i < 3; ++i) {
			color[1][i] = 1;
		}
		color[2][0] = 1;
		color[2][1] = 0;
		color[2][2] = 1;

		printf("Possible\n");
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				if (color[i][j] == 0) {
					printf("R");
				} else {
					printf("B");
				}
			}
			printf("\n");
		}
		return;
	}

	if (k == 1 || k == 2 * n * (n - 1) - 1) {
		printf("Impossible\n");
		return;
	}

	for (int c = 0; c < 2; ++c) {
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				color[i][j] = (i + j) % 2;
			}
		}

		if (solve(n, k, c)) {
			printf("Possible\n");
			for (int i = 0; i < n; ++i) {
				for (int j = 0; j < n; ++j) {
					if (color[i][j] == 0) {
						printf("R");
					} else {
						printf("B");
					}
				}
				printf("\n");
			}
			return;
		}
	}

	// printf("%d %d\n", n, k);
	printf("Impossible\n");
}

void run() {
	// for (int n = 1; n <= 50; ++n) {
	// 	for (int k = 0; k <= 2 * n * (n - 1); ++k) {
	// 		if (k == 1 || k == 2 * n * (n - 1) - 1) {
	// 			continue;
	// 		}
	// 		std::cout << n << ' ' << k << std::endl;
	// 		solve(n, k);

	// 		int cnt = 0;
	// 		for (int i = 0; i < n; ++i) {
	// 			for (int j = 0; j < n; ++j) {
	// 				if (i + 1 < n && color[i][j] != color[i + 1][j]) {
	// 					++cnt;
	// 				}
	// 				if (j + 1 < n && color[i][j] != color[i][j + 1]) {
	// 					++cnt;
	// 				}
	// 			}
	// 		}

	// 		assert(cnt == k);
	// 	}
	// }
    int t;
    scanf("%d", &t);

    while (t--) {
    	int n, k;
    	scanf("%d%d", &n, &k);

    	solve(n, k);
    }
}

int main(void) {
    // freopen(NAME".in", "r", stdin);
    // freopen(NAME".out", "w", stdout);

    #ifdef PERVEEVM_LOCAL
        auto start = std::chrono::high_resolution_clock::now();
    #endif

    run();

    #ifdef PERVEEVM_LOCAL
        auto end = std::chrono::high_resolution_clock::now();
        std::cerr << "Execution time: "
                  << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
                  << " ms" << std::endl;
    #endif

    return 0;
}