#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

using ll = long long;

using namespace std;

const int mod = 998244353;
inline int norm(int x) {
  return x >= mod ? x - mod : x;
}
inline int reduce(int x) {
  return x < 0 ? x + mod : x;
}
inline int neg(int x) {
  return x ? mod - x : 0;
}
inline void add(int &x, int y) {
  if ((x += y - mod) < 0)
    x += mod;
}
inline void sub(int &x, int y) {
  if ((x -= y) < 0)
    x += mod;
}
inline void fam(int &x, int y, int z) {
  x = (x + (ll)y * z) % mod;
}
inline int qpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1)
    (b & 1) && (ret = (ll)ret * a % mod),
    a = (ll)a * a % mod;
  return ret;
}

const int N = 1e6;

namespace Poly {
  const int LG = 20;
  const int N = 1 << LG + 1;
  const int G = 3;
  
  int lg2[N + 5];
  int fac[N + 5], ifac[N + 5], inv[N + 5];
  int rt[N + 5];
  
  inline void init() {
    for (int i = 2; i <= N; ++i)
      lg2[i] = lg2[i >> 1] + 1;
    rt[0] = 1, rt[1 << LG] = qpow(G, (mod - 1) >> LG + 2);
    for (int i = LG; i; --i)
      rt[1 << i - 1] = (ll)rt[1 << i] * rt[1 << i] % mod;
    for (int i = 1; i < N; ++i)
      rt[i] = (ll)rt[i & i - 1] * rt[i & -i] % mod;
    fac[0] = 1;
    for (int i = 1; i <= N; ++i)
      fac[i] = (ll)fac[i - 1] * i % mod;
    ifac[N] = qpow(fac[N], mod - 2);
    for (int i = N; i; --i)
      ifac[i - 1] = (ll)ifac[i] * i % mod;
    for (int i = 1; i <= N; ++i)
      inv[i] = (ll)ifac[i] * fac[i - 1] % mod;
  }
  
  struct poly {
    
    vector<int> a;
    inline poly(int x = 0) {
      if (x)
        a.push_back(x);
    }
    inline poly(const vector<int> &o) {
      a = o;
    }
    inline poly(const poly &o) {
      a = o.a;
    }
    
    inline int size() const {
      return a.size();
    }
    inline bool empty() const {
      return a.empty();
    }
    inline void resize(int x) {
      a.resize(x);
    }
    inline int operator[](int x) const {
      if (x < 0 || x >= size())
        return 0;
      return a[x];
    }
    inline void clear() {
      vector<int>().swap(a);
    }
    inline poly modxn(int n) const {
      if (a.empty())
        return poly();
      n = min(n, size());
      return poly(vector<int>(a.begin(), a.begin() + n));
    }
    inline poly rever() const {
      return poly(vector<int>(a.rbegin(), a.rend()));
    }
    
    inline void dif() {
      int n = size();
      for (int i = 0, len = n >> 1; len; ++i, len >>= 1)
        for (int j = 0, *w = rt; j < n; j += len << 1, ++w)
          for (int k = j; k < j + len; ++k) {
            int R = (ll)*w * a[k + len] % mod;
            a[k + len] = reduce(a[k] - R),
            add(a[k], R);
          }
    }
    inline void dit() {
      int n = size();
      for (int i = 0, len = 1; len < n; ++i, len <<= 1)
        for (int j = 0, *w = rt; j < n; j += len << 1, ++w)
          for (int k = j; k < j + len; ++k) {
            int R = norm(a[k] + a[k + len]);
            a[k + len] = (ll)*w * (a[k] - a[k + len] + mod) % mod,
            a[k] = R;
          }
      reverse(a.begin() + 1, a.end());
      for (int i = 0; i < n; ++i)
        a[i] = (ll)a[i] * inv[n] % mod;
    }
    inline void ntt(int type = 1) {
      type == 1 ? dif() : dit();
    }
    
    friend inline poly operator+(const poly &a, const poly &b) {
      vector<int> ret(max(a.size(), b.size()));
      for (int i = 0; i < ret.size(); ++i)
        ret[i] = norm(a[i] + b[i]);
      return poly(ret);
    }
    friend inline poly operator-(const poly &a, const poly &b) {
      vector<int> ret(max(a.size(), b.size()));
      for (int i = 0; i < ret.size(); ++i)
        ret[i] = reduce(a[i] - b[i]);
      return poly(ret);
    }
    friend inline poly operator*(poly a, poly b) {
      if (a.empty() || b.empty())
        return poly();
      if (a.size() < 40 || b.size() < 40) {
        if (a.size() > b.size())
          swap(a, b);
        poly ret;
        ret.resize(a.size() + b.size() - 1);
        for (int i = 0; i < ret.size(); ++i)
          for (int j = 0; j <= i && j < a.size(); ++j)
            ret.a[i] = (ret[i] + (ll)a[j] * b[i - j]) % mod;
        return ret;
      }
      int lim = 1, tot = a.size() + b.size() - 1;
      for (; lim < tot; lim <<= 1);
      a.resize(lim), b.resize(lim);
      a.ntt(), b.ntt();
      for (int i = 0; i < lim; ++i)
        a.a[i] = (ll)a[i] * b[i] % mod;
      a.ntt(-1), a.resize(tot);
      return a;
    }
    
    poly &operator+=(const poly &o) {
      resize(max(size(), o.size()));
      for (int i = 0; i < o.size(); ++i)
        add(a[i], o[i]);
      return *this;
    }
    poly &operator-=(const poly &o) {
      resize(max(size(), o.size()));
      for (int i = 0; i < o.size(); ++i)
        sub(a[i], o[i]);
      return *this;
    }
    poly &operator*=(poly o) {
      return (*this) = (*this) * o;
    }
    
    poly deriv() const {
      if (empty())
        return poly();
      vector<int> ret(size() - 1);
      for (int i = 0; i < size() - 1; ++i)
        ret[i] = (ll)(i + 1) * a[i + 1] % mod;
      return poly(ret);
    }
    poly integ() const {
      if (empty())
        return poly();
      vector<int> ret(size() + 1);
      for (int i = 0; i < size(); ++i)
        ret[i + 1] = (ll)a[i] * inv[i + 1] % mod;
      return poly(ret);
    }
    inline poly inver(int m) const {
      poly ret(qpow(a[0], mod - 2)), f, g;
      for (int k = 1; k < m;) {
        k <<= 1, f.resize(k), g.resize(k);
        for (int i = 0; i < k; ++i)
          f.a[i] = operator[](i), g.a[i] = ret[i];
        f.ntt(), g.ntt();
        for (int i = 0; i < k; ++i)
          f.a[i] = (ll)f[i] * g[i] % mod;
        f.ntt(-1);
        for (int i = 0; i < (k >> 1); ++i)
          f.a[i] = 0;
        f.ntt();
        for (int i = 0; i < k; ++i)
          f.a[i] = (ll)f[i] * g[i] % mod;
        f.ntt(-1);
        ret.resize(k);
        for (int i = (k >> 1); i < k; ++i)
          ret.a[i] = neg(f[i]);
      }
      return ret.modxn(m);
    }
    inline pair<poly, poly> div(poly o) const {
      if (size() < o.size())
        return make_pair(poly(), *this);
      poly f, g;
      f = (rever().modxn(size() - o.size() + 1) * o.rever().inver(size() - o.size() + 1))
          .modxn(size() - o.size() + 1).rever();
      g = (modxn(o.size() - 1) - o.modxn(o.size() - 1) * f.modxn(o.size() - 1)).modxn(o.size() - 1);
      return make_pair(f, g);
    }
    inline poly log(int m) const {
      return (deriv() * inver(m)).integ().modxn(m);
    }
    inline poly exp(int m) const {
      poly ret(1), iv, it, d = deriv(), itd, itd0, t1;
      if (m < 70) {
        ret.resize(m);
        for (int i = 1; i < m; ++i) {
          for (int j = 1; j <= i; ++j)
            ret.a[i] = (ret[i] + (ll)j * operator[](j) % mod * ret[i - j]) % mod;
          ret.a[i] = (ll)ret[i] * inv[i] % mod;
        }
        return ret;
      }
      for (int k = 1; k < m;) {
        k <<= 1;
        it.resize(k >> 1);
        for (int i = 0; i < (k >> 1); ++i)
          it.a[i] = ret[i];
        itd = it.deriv(), itd.resize(k >> 1);
        iv = ret.inver(k >> 1), iv.resize(k >> 1);
        it.ntt(), itd.ntt(), iv.ntt();
        for (int i = 0; i < (k >> 1); ++i)
          it.a[i] = (ll)it[i] * iv[i] % mod,
          itd.a[i] = (ll)itd[i] * iv[i] % mod;
        it.ntt(-1), itd.ntt(-1), sub(it.a[0], 1);
        for (int i = 0; i < k - 1; ++i)
          sub(itd.a[i % (k >> 1)], d[i]);
        itd0.resize((k >> 1) - 1);
        for (int i = 0; i < (k >> 1) - 1; ++i)
          itd0.a[i] = d[i];
        itd0 = (itd0 * it).modxn((k >> 1) - 1);
        t1.resize(k - 1);
        for (int i = (k >> 1) - 1; i < k - 1; ++i)
          t1.a[i] = itd[(i + (k >> 1)) % (k >> 1)];
        for (int i = k >> 1; i < k - 1; ++i)
          sub(t1.a[i], itd0[i - (k >> 1)]);
        t1 = t1.integ();
        for (int i = 0; i < (k >> 1); ++i)
          t1.a[i] = t1[i + (k >> 1)];
        for (int i = (k >> 1); i < k; ++i)
          t1.a[i] = 0;
        t1.resize(k >> 1), t1 = (t1 * ret).modxn(k >> 1), t1.resize(k);
        for (int i = (k >> 1); i < k; ++i)
          t1.a[i] = t1[i - (k >> 1)];
        for (int i = 0; i < (k >> 1); ++i)
          t1.a[i] = 0;
        ret -= t1;
      }
      return ret.modxn(m);
    }
    inline poly sqrt(int m) const {
      poly ret(1), f, g;
      for (int k = 1; k < m;) {
        k <<= 1;
        f = ret, f.resize(k >> 1);
        f.ntt();
        for (int i = 0; i < (k >> 1); ++i)
          f.a[i] = (ll)f[i] * f[i] % mod;
        f.ntt(-1);
        for (int i = 0; i < k; ++i)
          sub(f.a[i % (k >> 1)], operator[](i));
        g = (2 * ret).inver(k >> 1), f = (f * g).modxn(k >> 1), f.resize(k);
        for (int i = (k >> 1); i < k; ++i)
          f.a[i] = f[i - (k >> 1)];
        for (int i = 0; i < (k >> 1); ++i)
          f.a[i] = 0;
        ret -= f;
      }
      return ret.modxn(m);
    }
    inline poly pow(int m, int k1, int k2 = -1) const {
      if (empty())
        return poly();
      if (k2 == -1)
        k2 = k1;
      int t = 0;
      for (; t < size() && !a[t]; ++t);
      if ((ll)t * k1 >= m)
        return poly();
      poly ret;
      ret.resize(m);
      int u = qpow(a[t], mod - 2), v = qpow(a[t], k2);
      for (int i = 0; i < m - t * k1; ++i)
        ret.a[i] = (ll)operator[](i + t) * u % mod;
      ret = ret.log(m - t * k1);
      for (int i = 0; i < ret.size(); ++i)
        ret.a[i] = (ll)ret[i] * k1 % mod;
      ret = ret.exp(m - t * k1), t *= k1, ret.resize(m);
      for (int i = m - 1; i >= t; --i)
        ret.a[i] = (ll)ret[i - t] * v % mod;
      for (int i = 0; i < t; ++i)
        ret.a[i] = 0;
      return ret;
    }
  };
}
using Poly::fac;
using Poly::ifac;
using Poly::inv;
using Poly::init;
using Poly::poly;

inline int binom(int n, int m) {
  return n < m || m < 0 ? 0 : (ll)fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}

ll r;
int b, n;
poly u, v;
int ans;
int main() {
  init();
  
  scanf("%lld%d", &r, &b), n = (r / b) % mod, r %= mod;
  u.resize(b + 2), v.resize(b + 2);
  for (int i = 0, p = 1; i <= b + 1; ++i)
    p = (ll)p * (n + 1) % mod,
    u.a[i] = (ll)p * ifac[i + 1] % mod,
    v.a[i] = ifac[i + 1];
  u = (u * v.inver(b + 2)).modxn(b + 2);
  for (int i = 0; i <= b + 1; ++i)
    u.a[i] = (ll)u[i] * fac[i] % mod;
  sub(u.a[0], 1);
  for (int i = 0, c = 1; i <= b; ++i)
    ans = (ans + ((r + 1) * u[b - i] + (ll)(mod - b) * u[b - i + 1]) % mod * c) % mod,
    c = c * (r + b + 1 - i) % mod * inv[i + 1] % mod;
  printf("%d\n", ans);
}