#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

struct mint {
    static constexpr int MOD = 998244353;

    static constexpr mint pow(mint base, long exp) {
        mint ans = 1;
        while (exp) {
            if (exp & 1) {
                ans *= base;
            }
            base *= base;
            exp >>= 1;
        }
        return ans;
    }

    static constexpr int norm(long x) {
        x %= MOD;
        if (x < 0) {
            x += MOD;
        }
        return int(x);
    }

    int x;

    constexpr mint() : x(0) {}
    constexpr mint(long x) : x(norm(x)) {}

    static constexpr mint from_unchecked(int x) {
        mint m;
        m.x = x;
        return m;
    }

    friend ostream& operator<<(ostream& out, mint m) {
        return out << m.x;
    }

    mint operator-() const {
        if (!x) {
            return 0;
        }
        return from_unchecked(MOD - x);
    }

    mint& operator+=(const mint& m) {
        x += m.x;
        if (x >= MOD) {
            x -= MOD;
        }
        return *this;
    }
    mint& operator-=(const mint& m) {
        return *this += -m;
    }

    mint& operator*=(const mint& m) {
        x = int(long(x) * m.x % MOD);
        return *this;
    }

    friend mint operator+(mint a, const mint& b) {
        return a += b;
    }
    friend mint operator-(mint a, const mint& b) {
        return a -= b;
    }
    friend mint operator*(mint a, const mint& b) {
        return a *= b;
    }
};

int n, m, ans = 0;
vector<int> carr;

void dfs(int ind) {
    if (ind == n) {
        int g = 0;
        for (auto& a : carr) {
            g = gcd(g, a);
        }
        ans += g == 0 || g == 1;
        return;
    }
    for (int i = -m; i <= m; i++) {
        carr.push_back(i);
        dfs(ind + 1);
        carr.pop_back();
    }
}

void solve() {
    cin >> n >> m;
    mint dp[m + 1] {};
    for (int i = m; i >= 1; i--) {
        dp[i] = mint::pow(2 * (m / i) + 1, n) - 1;
        for (int j = 2 * i; j <= m; j += i) {
            dp[i] -= dp[j];
        }
    }
    cout << dp[1] + 1 << endl;
    // dfs(0);
    // cout << ans << endl;
    // mint p = 0;
    // for (int i = 1; i <= m; i++) {
    //     for (int j = 1; j <= m; j++) {
    //         p += gcd(i, j) == 1;
    //     }
    // }
    // mint dp[2][n + 1] {};
    // dp[0][0] = dp[1][0] = 1;
    // for (int i = 1; i <= n; i++) {
    //     dp[0][i] = dp[0][i - 1] + 2 * dp[1][i - 1];
    //     dp[1][i] = dp[1][i - 1] + 2 * p * mint::pow(2 * m + 1, i - 1);
    // }
    // cout << dp[0][n] << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}