#include<bits/stdc++.h>
using namespace std;
#include<atcoder/all>
using namespace atcoder;
#define rep2(i, m, n) for (int i = (m); i < (n); ++i)
#define rep(i, n) rep2(i, 0, n)
#define drep2(i, m, n) for (int i = (m)-1; i >= (n); --i)
#define drep(i, n) drep2(i, n, 0)

// https://opt-cp.com/fps-implementation/
template<typename T>
struct FormalPowerSeries : vector<T> {
  using vector<T>::vector;
  using vector<T>::operator=;
  using F = FormalPowerSeries;
  F operator-() const {
    F res(*this);
    for (auto &e : res) e = -e;
    return res;
  }
  F &operator*=(const T &g) {
    for (auto &e : *this) e *= g;
    return *this;
  }
  F &operator/=(const T &g) {
    assert(g != T(0));
    *this *= g.inv();
    return *this;
  }
  F &operator+=(const F &g) {
    int n = (*this).size(), m = g.size();
    (*this).resize(max(n, m));
    rep(i, m) (*this)[i] += g[i];
    return *this;
  }
  F &operator-=(const F &g) {
    int n = (*this).size(), m = g.size();
    (*this).resize(max(n, m));
    rep(i, m) (*this)[i] -= g[i];
    return *this;
  }
  F &operator<<=(int d) {
    (*this).insert((*this).begin(), d, 0);
    return *this;
  }
  F &operator>>=(int d) {
    int n = (*this).size();
    (*this).erase((*this).begin(), (*this).begin() + min(n, d));
    return *this;
  }
  F inv(int d = -1) const {
    int n = (*this).size();
    assert(n != 0 && (*this)[0] != 0);
    if (d == -1) d = n;
    assert(d > 0);
    F res{(*this)[0].inv()};
    while (res.size() < d) {
      int m = size(res);
      F f(begin(*this), begin(*this) + min(n, 2*m));
      F r(res);
      f.resize(2*m), internal::butterfly(f);
      r.resize(2*m), internal::butterfly(r);
      rep(i, 2*m) f[i] *= r[i];
      internal::butterfly_inv(f);
      f.erase(f.begin(), f.begin() + m);
      f.resize(2*m), internal::butterfly(f);
      rep(i, 2*m) f[i] *= r[i];
      internal::butterfly_inv(f);
      T iz = T(2*m).inv(); iz *= -iz;
      for (auto &e : f) e *= iz;
      res.insert(res.end(), f.begin(), f.begin() + m);
    }
    return {res.begin(), res.begin() + d};
  }
  F &operator*=(const F &g) {
    *this = convolution(*this, g);
    return *this;
  }
  F &operator/=(const F &g) {
    int n = (*this).size(), m = g.size();
    *this = convolution(*this, g.inv(max(n, m)));
    (*this).resize(n);
    return *this;
  }
  F operator*(const T &g) const { return F(*this) *= g; }
  F operator/(const T &g) const { return F(*this) /= g; }
  F operator+(const F &g) const { return F(*this) += g; }
  F operator-(const F &g) const { return F(*this) -= g; }
  F operator*(const F &g) const { return F(*this) *= g; }
  F operator/(const F &g) const { return F(*this) /= g; }
  F operator<<(const int d) const { return F(*this) <<= d; }
  F operator>>(const int d) const { return F(*this) >>= d; }
  void multiply_naive(const F &g) {
    int n = size(*this), m = size(g);
    (*this).resize(n+m-1);
    drep(i, n+m-1) {
      (*this)[i] *= g[0];
      rep2(j, 1, min(i+1, m)) (*this)[i] += (*this)[i-j] * g[j];
    }
  }
  void divide_naive(const F &g) {
    assert(g[0] != T(0));
    T ig0 = g[0].inv();
    int n = size(*this), m = size(g);
    rep(i, n) {
      rep2(j, 1, min(i+1, m)) (*this)[i] -= (*this)[i-j] * g[j];
      (*this)[i] *= ig0;
    }
  }
  void multiply(vector<pair<int, T>> g) { // sparse
    int n = (*this).size();
    auto [d, c] = g.front();
    if (d == 0) g.erase(g.begin());
    else c = 0;
    drep(i, n) {
      (*this)[i] *= c;
      for (auto &[j, b] : g) {
        if (j > i) break;
        (*this)[i] += (*this)[i-j] * b;
      }
    }
  }
  void divide(vector<pair<int, T>> g) { // sparse, required: "g[0] == (0, c)" and "c != 0"
    int n = (*this).size();
    auto [d, c] = g.front();
    assert(d == 0 && c != T(0));
    T ic = c.inv();
    g.erase(g.begin());
    rep(i, n) {
      for (auto &[j, b] : g) {
        if (j > i) break;
        (*this)[i] -= (*this)[i-j] * b;
      }
      (*this)[i] *= ic;
    }
  }
  void multiply(const int d, const T c) { // multiply (1 + cz^d)
    int n = (*this).size();
    drep(i, n-d) (*this)[i+d] += (*this)[i] * c;
  }
  void divide(const int d, const T c) { // divide by (1 + cz^d)
    int n = (*this).size();
    rep(i, n-d) (*this)[i+d] -= (*this)[i] * c;
  }
  T eval(const T &a) {
    T x(1), res(0);
    for (auto e : *this) res += e * x, x *= a;
    return res;
  }
};

using mint = modint998244353;
using fps = FormalPowerSeries<mint>;
using sfps = vector<pair<int, mint>>;

int main()
{
  int N, M;
  cin >> N >> M;
  
  fps P(N + 1, 0);
  for (int i = 1; i <= M; i++)
  {
    for (int k = 1; k * i <= N; k++)
    {
      P.at(k * i)++;
    }
  }

  fps Q(N + 1);
  for (int i = 0; i <= N; i++)
  {
    Q.at(i) = mint(M).pow(i);
  }

  fps R(N + 1);
  R.at(0) = 1;
  for (int i = 1; i <= N; i++)
  {
    R.at(i) = (M - 1) * mint(M).pow(i - 1);
  }

  fps G = Q / (fps(1, 1) + P * R);
  mint ans = Q.at(N) - G.at(N);
  cout << ans.val() << endl;
}