#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef pair<__int128_t, __int128_t> P128;


template<class T1, class T2>
pair<T1, T2> operator+ (const pair<T1, T2> &l, const pair<T1, T2> &r) {
	return {l.first + r.first, l.second + r.second};
}
template<class T1, class T2>
pair<T1, T2> operator- (const pair<T1, T2> &l, const pair<T1, T2> &r) {
	return {l.first - r.first, l.second - r.second};
}

pair<__int128_t, bool> deduce1 (P128 p, __int128_t a0, __int128_t val) {
	__int128_t war = val - p.first * a0;

	return {war / p.second, (war % p.second == 0)};
}
// pair<__int128_t, bool> deduce1 (__int128_t p, __int128_t val) {
// 	return {val / p, (val % p == 0)};
// }

vector<P> ans;
vector<ll> xs;

const ll MIN_A = 0, MAX_A = 1'000'000;


ll n, m;
const ll FOD = 998244353;

ll bpow (ll x, ll e) {
	x %= FOD;
	ll ans = 1;
	while (e) {
		if (e % 2 == 1) {
			ans = ans * x % FOD;
		}
		x = x * x % FOD;
		e /= 2;
	}
	return ans;
}
ll binv (ll x) {
	return bpow(x % FOD, FOD - 2);
}

vector<ll> frac, invf;
void f_init (ll n) {
	frac.resize(n+1);
	invf.resize(n+1);

	frac[0] = 1;
	for (ll i = 1; i <= n; i++) {
		frac[i] = (frac[i-1] * i) % FOD;
	}
	invf[n] = binv(frac[n]);
	for (ll i = n; i >= 1; i--) {
		invf[i-1] = (invf[i] * i) % FOD;
	}
}

ll ncr (ll n, ll r) {
	if (n < 0 || r < 0 || n-r < 0) return 0;
	return (frac[n] * (invf[r] * invf[n-r] % FOD)) % FOD;
}

ll f (ll n, ll r) {
	if (n < 0 || r < 0) return 0;
	// r non-negatives, sum <= n
	// r+1 non-negatives, sum == n

	return ncr(n+r, n);
}

int main (void) {
	cin >> n >> m;

	f_init(n+m+5);

	if (n == 1) {
		ll ans1 = (m-1) * binv(2) % FOD;
		cout << ans1 << "\n";
		return 0;
	}

	ll allcnt = (f(m, n) + FOD - n) % FOD;

	vector<ll> scorecnt(m+1);
	ll sum = 0;
	for (ll i = 1; i <= m-1; i++) {
		scorecnt[i] = f(m - n*i, n);
		sum += scorecnt[i];
		sum %= FOD;
	}

	ll ans = sum * binv(allcnt) % FOD;
	cout << ans << "\n";


	return 0;
}