#include <bits/stdc++.h>

#define fir first
#define sec second
#define mkp make_pair
#define mkt make_tuple
#ifdef LOCAL
#define dbg(x) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << '\n'
#define dpi(x, y) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << " ; " << "the " << #y << " = " << y << '\n'
#define dbgf(fmt, args...) fprintf(stderr, fmt, ##args)
#else
#define dbg(x) void()
#define dpi(x, y) void()
#define dbgf(fmt, args...) void()
#endif

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ui = unsigned int;
using ldb = long double;
using i128 = __int128_t;
using ui128 = __uint128_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using vi = vector<int>;
using vpii = vector<pii>;

namespace {
bool Mbe;
constexpr int MOD = 998244353;
template<typename T> T Norm(T a, T p = MOD) { return (a % p + p) % p; }
template<typename T> T add(T a, T b, T p = MOD) { return (a + b >= p) ? (a + b - p) : (a + b); }
template<typename T> T del(T a, T b, T p = MOD) { return (a - b < 0) ? (a - b + p) : (a - b); }
template<typename T> T mul(T a, T b, T p = MOD) { return 1ll * a * b % p; }
template<typename T> T cadd(T &a, T b, T p = MOD) { return a = add(a, b, p); }
template<typename T> T cdel(T &a, T b, T p = MOD) { return a = del(a, b, p); }
template<typename T> T cmul(T &a, T b, T p = MOD) { return a = mul(a, b, p); }
template<typename T> bool cmax(T &a, T b) { return a < b ? a = b, true : false; }
template<typename T> bool cmin(T &a, T b) { return a > b ? a = b, true : false; }
template<typename T> T DivFloor(T a, T b) { return a >= 0 ? a / b : (a - b + 1) / b; }
template<typename T> T DivCeil(T a, T b) { return a >= 0 ? (a + b - 1) / b : a / b; }

namespace FastIO {
	constexpr int LEN = 1 << 20;
	char in[LEN + 1], out[LEN + 1];
	char *pin = in, *pout = out, *ein = in, *eout = out + LEN;

	char gc() { return pin == ein && (ein = (pin = in) + fread(in, 1, LEN, stdin), ein == in) ? EOF : *pin ++; }
	void pc(char c) { pout == eout && (fwrite(out, 1, LEN, stdout), pout = out); (*pout ++) = c; return; }
	struct Flush { ~Flush() { fwrite(out, 1, pout - out, stdout); pout = out; return; } } _flush;

	template<typename T> T Read() {
		T x = 0; int f = 1; char ch = gc();
		while (ch < '0' || ch > '9') f = (ch == '-' ? (~f + 1) : f), ch = gc();
		while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc();
		return x * f;
	}
	void Read(char *s) {
		char ch = gc();
		while (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') ch = gc();
		while ((ch != EOF) && !(ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t')) *s = ch, s ++, ch = gc();
		*s = '\0'; return;
	}
	template<typename T> void Read(T &x) { x = Read<T>(); return; }
	template<typename T, typename ...Args>
	void Read(T &x, Args &...args) { Read(x), Read(args...); return; }
	template<typename T> void Write(T x) {
		static char stk[40]; int tp = 0;
		if (x < 0) pc('-'), x = ~x + 1;
		do stk[tp++] = x % 10 + 48, x /= 10; while (x);
		while (tp --) pc(stk[tp]);
		return;
	}
	void Write(char ch) { pc(ch); return; }
	void Write(const char *s) {
		while (*s != '\0') pc(*s), s ++;
		return;
	}
	void Puts(const char *s) {
		Write(s), pc('\n'); return;
	}
	template<typename T, typename ...Args>
	void Write(T x, Args ...args) { Write(x), Write(args...); return; }
}
#define Read FastIO::Read
#define Write FastIO::Write
#define Puts FastIO::Puts
#define getchar FastIO::gc
#define putchar FastIO::pc

template<unsigned P>
struct Static_Modint {
	unsigned x; static constexpr unsigned Mod = P;
	constexpr Static_Modint(): x(0U) {}
	constexpr Static_Modint(unsigned _x): x(_x % Mod) {}
	constexpr Static_Modint(unsigned long long _x): x(_x % Mod) {}
	constexpr Static_Modint(int _x): x(((_x %= static_cast<int>(Mod)) < 0) ? (_x + static_cast<int>(Mod)) : _x) {}
	constexpr Static_Modint(long long _x): x(((_x %= static_cast<long long>(Mod)) < 0) ? (_x + static_cast<long long>(Mod)) : _x) {}
	explicit constexpr operator unsigned() const {
		return static_cast<unsigned>(x);
	}
	explicit constexpr operator unsigned long long() const {
		return static_cast<unsigned long long>(x);
	}
	explicit constexpr operator int() const {
		return static_cast<int>(x);
	}
	explicit constexpr operator long long() const {
		return static_cast<long long>(x);
	}
	explicit constexpr operator bool() const {
		return x;
	}
	constexpr Static_Modint &operator += (const Static_Modint &rhs) {
		x = ((x += rhs.x) >= Mod) ? (x - Mod) : x;
		return *this;
	}
	constexpr Static_Modint &operator -= (const Static_Modint &rhs) {
		x = ((x -= rhs.x) >= Mod) ? (x + Mod) : x;
		return *this;
	}
	constexpr Static_Modint &operator *= (const Static_Modint &rhs) {
		x = (static_cast<unsigned long long>(x) * rhs.x) % Mod;
		return *this;
	}
	constexpr Static_Modint &operator /= (const Static_Modint &rhs) {
		return (*this *= rhs.inv());
	}
	constexpr Static_Modint inv() const {
		unsigned a = Mod, b = x; int y = 0, z = 1;
		while (b) {
			const unsigned q = a / b;
			const unsigned c = a - q * b;
			a = b, b = c;
			const int w = y - static_cast<int>(q) * z;
			y = z, z = w;
		}
		return Static_Modint(y);
	}
	friend constexpr Static_Modint operator + (const Static_Modint &x) {
		return x;
	}
	friend constexpr Static_Modint operator - (Static_Modint x) {
		x.x = x.x ? (Mod - x.x) : 0U;
		return x;
	}
	constexpr Static_Modint &operator ++ () {
		x = (x + 1 == Mod) ? 0U : (x + 1);
		return *this;
	}
	constexpr Static_Modint &operator -- () {
		x = (x == 0U) ? (Mod - 1) : (x - 1);
		return *this;
	}
	constexpr Static_Modint operator ++ (int) {
		Static_Modint tmp = (*this);
		return ++ (*this), tmp;
	}
	constexpr Static_Modint operator -- (int) {
		Static_Modint tmp = (*this);
		return -- (*this), tmp;
	}
	friend constexpr Static_Modint operator + (Static_Modint x, const Static_Modint &y) {
		return x += y;
	}
	friend constexpr Static_Modint operator - (Static_Modint x, const Static_Modint &y) {
		return x -= y;
	}
	friend constexpr Static_Modint operator * (Static_Modint x, const Static_Modint &y) {
		return x *= y;
	}
	friend constexpr Static_Modint operator / (Static_Modint x, const Static_Modint &y) {
		return x /= y;
	}
	constexpr Static_Modint Pow(long long y) const {
		if (y < 0) return inv().Pow(- y);
		Static_Modint x = *this, ans;
		ans.x = 1U;
		for (; y; y >>= 1, x *= x)
			if (y & 1) ans *= x;
		return ans;
	}
	friend constexpr ostream& operator << (ostream& os, const Static_Modint &x) {
		return os << x.x;
	}
	friend constexpr bool operator == (const Static_Modint &x, const Static_Modint &y) {
		return x.x == y.x;
	}
	friend constexpr bool operator != (const Static_Modint &x, const Static_Modint &y) {
		return x.x != y.x;
	}
	friend constexpr bool operator <= (const Static_Modint &x, const Static_Modint &y) {
		return x.x <= y.x;
	}
	friend constexpr bool operator >= (const Static_Modint &x, const Static_Modint &y) {
		return x.x >= y.x;
	}
	friend constexpr bool operator < (const Static_Modint &x, const Static_Modint &y) {
		return x.x < y.x;
	}
	friend constexpr bool operator > (const Static_Modint &x, const Static_Modint &y) {
		return x.x > y.x;
	}
}; using mint = Static_Modint<MOD>;

struct Combination {
	int N;
	vector<mint> _fac, _ifac, _inv;
	
	Combination(int n) { Init(n); return; }
	Combination(): N(0), _fac{1}, _ifac{1}, _inv{0} { return; }
	void Init(int n) {
		if (n <= N) return;
		_fac.resize(n + 1), _ifac.resize(n + 1), _inv.resize(n + 1);
		for (int i = N + 1; i <= n; i ++) _fac[i] = _fac[i - 1] * i;
		_ifac[n] = _fac[n].inv();
		for (int i = n; i > N; i --) _ifac[i - 1] = _ifac[i] * i,
																 _inv[i] = _ifac[i] * _fac[i - 1];
		N = n; return;
	}
	mint fac(int n) {
		if (n > N) Init(n << 1);
		return _fac[n];
	}
	mint ifac(int n) {
		if (n > N) Init(n << 1);
		return _ifac[n];
	}
	mint inv(int n) {
		if (n > N) Init(n << 1);
		return _inv[n];
	}
	mint C(int n, int m) {
		if (n < m || n < 0 || m < 0) return 0;
		return fac(n) * ifac(m) * ifac(n - m);
	}
} comb;

void slv() {
	ll n, k; Read(n, k);
	
	ll l = 0, r = (n + 1) / 2;
	while (l < r) {
		ll mid = (l + r + 1) >> 1;
		if (mid * (n + 1 - mid) <= k) {
			l = mid;
		} else {
			r = mid - 1;
		}
	}
	if (l * (n + 1 - l) == k) {
		mint ans = comb.C(n + 1, l);
		if (l == n + 1 - l)
			ans *= (MOD + 1) / 2;
		Write((int)ans, '\n');
	} else {
		Puts("0");
	}
	return;
}
void clr() {

	return;
}
bool Med;
}

int main() {
#ifdef LOCAL
	freopen("!in.in", "r", stdin);
	freopen("!out.out", "w", stdout);
	fprintf(stderr, "%.3lf Mb\n", fabs((&Mbe - &Med) / 1048576.0));
#endif
//	int T = 1;
	int T = Read<int>();
	while (T --) slv(), clr();
#ifdef LOCAL
	fprintf(stderr, "%d ms\n", (int)clock());
#endif
	return 0;
}