#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
using db = long double; // or double if tight TL
using str = string;

using pi = pair<int,int>;
#define mp make_pair
#define f first
#define s second

#define tcT template<class T
tcT> using V = vector<T>; 
tcT, size_t SZ> using AR = array<T,SZ>;
using vi = V<int>;
using vb = V<bool>;
using vpi = V<pi>;
using vl = V<ll>;

#define sz(x) int((x).size())
#define all(x) begin(x), end(x)
#define sor(x) sort(all(x))
#define rsz resize
#define pb push_back
#define ft front()
#define bk back()

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)

const int MOD = 998244353;
// const int MOD = 1e9+7;
const ll INF = 1e18;
const db PI = acos((db)-1);
mt19937 rng(0); // or mt19937_64

tcT> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; } // set a = max(a,b)

tcT, class U> T fstTrue(T lo, T hi, U f) {
    ++hi; assert(lo <= hi); // assuming f is increasing
    while (lo < hi) { // find first index such that f is true 
        T mid = lo+(hi-lo)/2;
        f(mid) ? hi = mid : lo = mid+1; 
    } 
    return lo;
}

struct mi{
    int v; explicit operator int() const {return v;}
    mi():v(0) {}
    mi(ll _v): v(int(_v%MOD)){v+= (v<0)*MOD;}
};

mi& operator+=(mi& a, mi b){
    if((a.v+=b.v) >= MOD) a.v-=MOD;
    return a;
}

mi& operator-=(mi& a, mi b){
    if((a.v-=b.v) < 0) a.v+=MOD;
    return a;
}

mi operator+(mi a, mi b){
    return a+=b;
}

mi operator-(mi a, mi b){
    return a-=b;
}

mi operator*(mi a, mi b){
    return mi((ll)a.v*b.v);
}

using vmi = vector<mi>;

vmi invs, fac, ifac;
void genFac(int SZ){
    invs.rsz(SZ), fac.rsz(SZ), ifac.rsz(SZ);
    invs[1] = fac[0] = ifac[0] = 1;
    FOR(i,2,SZ) invs[i] = mi(-(ll)MOD/i*(int)invs[MOD%i]);
    FOR(i,1,SZ) fac[i] = fac[i-1]*i, ifac[i] = ifac[i-1]*invs[i];
}

mi comb(int a, int b){
    if(a < b || b < 0) return 0;
    return fac[a]*ifac[b]*ifac[a-b];
}

mi choose2(mi a){
    return a*(a-1)*invs[2];
}

mi dp[105][105];
struct Eff{

mi f(int n, int m){
    return comb(n+m-2, m-1)*comb(n+m-2, n-1)-comb(n+m-2, m)*comb(n+m-2, n);
}

void solve(){
    genFac(1000005);

    int N, M;
    cin >> N >> M;
    cout << f(N, M).v << "\n";
}

};

int main() { 
    cin.tie(0)->sync_with_stdio(0);
    Eff e; e.solve();
}