#include <bits/stdc++.h>
using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;
template<class T>constexpr T qpw(T a, u64 b, T r = 1) {
    for (; b; b >>= 1, a *= a) {
        b & 1 ? r *= a : r;
    }

    return r;
}
template<u32 P>constexpr u32 dil(u32 x) {
    return x >> 31 ? x + P : x;
}
template<u32 P>constexpr u32 sf_md(i64 x) {
    return dil<P>(x % P);
}
template<u32 P>struct mint {
    u32 x;
    mint() = default;
    constexpr mint(u32 y): x(y) {}
    static constexpr mint get(i64 x) {
        return sf_md<P>(x);
    }
    explicit constexpr operator u32() {
        return x;
    }
    constexpr mint operator - ()const {
        return dil<P>(-x);
    }
    constexpr mint inv()const {
        return qpw(*this, P - 2);
    }
    friend constexpr mint operator + (mint lhs, mint rhs) {
        return dil<P>(lhs.x + rhs.x - P);
    }
    friend constexpr mint operator - (mint lhs, mint rhs) {
        return dil<P>(lhs.x - rhs.x);
    }
    friend constexpr mint operator * (mint lhs, mint rhs) {
        return u64(lhs.x) * rhs.x % P;
    }
    friend constexpr mint operator / (mint lhs, mint rhs) {
        return qpw(rhs, P - 2, lhs);
    }
    constexpr mint &operator += (mint rhs) {
        return (*this) = (*this) + rhs;
    }
    constexpr mint &operator -= (mint rhs) {
        return (*this) = (*this) - rhs;
    }
    constexpr mint &operator *= (mint rhs) {
        return (*this) = (*this) * rhs;
    }
    constexpr mint &operator /= (mint rhs) {
        return (*this) = (*this) / rhs;
    }
    friend std::istream &operator >>(std::istream &is, mint &x) {
        i64 v;
        is >> v, x = get(v);
        return is;
    }
    friend std::ostream &operator <<(std::ostream &os, mint x) {
        return os << x.x;
    }
};
using Z = mint < u32(998244353) >;
constexpr Z operator ""_z(u64 x) {
    return Z::get(x);
}
template<class T>struct binom {
    std::vector<T> fac, ifac;
    void reserve(int n) {
        if (n >= int(fac.size())) {
            n = n * 2;
        } else {
            return;
        }

        fac.resize(n + 1), ifac.resize(n + 1);
        fac[0] = 1;

        for (int i = 1; i <= n; ++i) {
            fac[i] = fac[i - 1] * i;
        }

        ifac[n] = fac[n].inv();

        for (int i = n; i > 0; --i) {
            ifac[i - 1] = ifac[i] * i;
        }
    }
    T operator()(int n, int k) {
        if (k > n || k < 0) {
            return 0;
        }

        reserve(n);
        return fac[n] * ifac[n - k] * ifac[k];
    }
};
binom<Z> C;
Z fac(int n) {
    C.reserve(n);
    return C.fac[n];
}
Z ifac(int n) {
    C.reserve(n);
    return C.ifac[n];
}
using std::cin;
using std::cout;
void solve() {
    int n, k;
    cin >> n >> k;
    ++n, --k;
    Z ans = C(k + n - 1, k);

    if (n >= k) {
        for (int i = 1;; ++i) {
            int j = (i * (3 * i - 1)) >> 1;

            if (j > k) {
                break;
            }

            auto tmp = C(k - j + n - 1, k - j);
            ans += (i & 1) ? -tmp : tmp;

            if (j + i <= k) {
                auto tmp = C(k - i - j + n - 1, k - i - j);
                ans += (i & 1) ? -tmp : tmp;
            }
        }
    } else {
        std::vector<Z> f(k + 1);

        for (int i = 0; i <= k; ++i) {
            f[i] = C(i + n - 1, i);
        }

        for (int i = 1;; ++i) {
            int j = (i * (i + 1)) >> 1;

            if (j > k) {
                break;
            }

            for (int w = k - j; w >= n - i + 1; --w) {
                f[w] -= f[w - n + i - 1];
            }

            for (int w = i; w <= k - j; ++w) {
                f[w] += f[w - i];
            }

            auto tmp = f[k - j];
            ans += (i & 1) ? -tmp : tmp;
        }
    }
    // int now = 0;
    ans *= C.ifac[n - 1];
    cout << ans;
    // int now = ans * ifac[n];
    // cout << now;
}
int main() {
	// freopen(".in", "r", stdin);
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    solve();
    return 0;
}