#line 1 "e.cpp"
/*
  Author : MatsuTaku
  Date   : 03/25/22
*/

#include <bits/stdc++.h>
#include <x86intrin.h>
//#include <atcoder/all>
#line 3 "/mnt/c/Users/tkmma/competitive_programming/CPBF/library/include/modular.hpp"

template <long long MOD> class Modular {
private:
  long long val_;

public:
  constexpr Modular() : val_(0) {}
  constexpr Modular(long long v) : val_(v % MOD) {
    if (val_ < 0)
      val_ += MOD;
  }

  constexpr long long val() const { return val_; }
  constexpr Modular &operator+=(Modular x) {
    val_ += x.val();
    if (val_ >= MOD)
      val_ %= MOD;
    return *this;
  }
  constexpr Modular operator-() const { return {MOD - val_}; }
  constexpr Modular &operator-=(Modular x) {
    val_ -= x.val();
    if (val_ < 0)
      val_ += MOD;
    return *this;
  }
  constexpr Modular &operator*=(Modular x) {
    val_ *= x.val();
    if (val_ >= MOD)
      val_ %= MOD;
    return *this;
  }
  constexpr Modular pow(long long p) const {
    Modular t = 1;
    Modular u = *this;
    while (p) {
      if (p & 1)
        t *= u;
      u *= u;
      p >>= 1;
    }
    return t;
  }
  friend constexpr Modular pow(Modular x, long long p) { return x.pow(p); }
  constexpr Modular inv() const { return pow(MOD - 2); }
  constexpr Modular &operator/=(Modular x) { return *this *= x.inv(); }
  constexpr Modular operator+(Modular x) const { return Modular(*this) += x; }
  constexpr Modular operator-(Modular x) const { return Modular(*this) -= x; }
  constexpr Modular operator*(Modular x) const { return Modular(*this) *= x; }
  constexpr Modular operator/(Modular x) const { return Modular(*this) /= x; }
  constexpr Modular &operator++() { return *this += 1; }
  constexpr Modular operator++(int) {
    Modular c = *this;
    ++(*this);
    return c;
  }
  constexpr Modular &operator--() { return *this -= 1; }
  constexpr Modular operator--(int) {
    Modular c = *this;
    --(*this);
    return c;
  }

  constexpr bool operator==(Modular x) const { return val() == x.val(); }
  constexpr bool operator!=(Modular x) const { return val() != x.val(); }
  constexpr bool operator<(Modular x) const { return val() < x.val(); };
  constexpr bool operator<=(Modular x) const { return val() <= x.val(); };
  constexpr bool operator>(Modular x) const { return val() > x.val(); };
  constexpr bool operator>=(Modular x) const { return val() >= x.val(); };

  friend std::ostream &operator<<(std::ostream &os, const Modular &x) {
    return os << x.val();
  }
  friend std::istream &operator>>(std::istream &is, Modular &x) {
    return is >> x.val_;
  }
};

using Modular998244353 = Modular<998244353>;
using Modular1000000007 = Modular<(int)1e9 + 7>;
#line 10 "e.cpp"
#define _overload3(_1, _2, _3, target, ...) target
#define _REP(i, l, r) for (int i = (l), i##_less = (r); i < i##_less; i++)
#define _rep(i, n) _REP(i, 0, n)
#define rep(args...) _overload3(args, _REP, _rep)(args)
#define _RREP(i, l, r) for (int i = (r)-1, i##_least = (l); i >= i##_least; i--)
#define _rrep(i, n) _RREP(i, 0, n)
#define rrep(args...) _overload3(args, _RREP, _rrep)(args)
#define chmax(dst, x) dst = max(dst, (x))
#define chmin(dst, x) dst = min(dst, (x))
using namespace std;
using lint = long long int;
using ulint = unsigned long long int;
template <typename T> using vvec = vector<vector<T>>;
template <typename T> vvec<T> make_vvec(int n, int m, T v) {
  return vvec<T>(n, vector<T>(m, v));
}
template <typename T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;

class Solver {
public:
  Solver();
  void solve();
};

Solver::Solver() {}

using mint = Modular998244353;

void Solver::solve() {
  int n, m;
  cin >> n >> m;
  auto dp = make_vvec<mint>(n + 1, m + 1, 0);
  vector<mint> dpsum(n + 1);
  dp[0][0] = 1;
  dpsum[0] = 1;
  rep(i, 1, n + 1) {
    rep(j, 1, m + 1) {
      dp[i][j] = dpsum[i - 1];
      if (i - j >= 0) {
        dp[i][j] -= dpsum[i - j] - dp[i - j][j];
      }
      dpsum[i] += dp[i][j];
    }
  }
  cout << mint(m).pow(n) - dpsum[n] << endl;
}

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  Solver solver;
  int t = 1;
  //  cin>>t;
  while (t--) {
    solver.solve();
  }
  return 0;
}