// #pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>

#define all(x) (x).begin(),(x).end()
#define sz(x) int(x.size())

using namespace std;
using ll = long long;
using pii = pair<int, int>;
template<typename... T> void rd(T&... args) {((cin>>args), ...);}
template<typename... T> void wr(T... args) {((cout<<args<<" "), ...); cout<<'\n';}
template<typename T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; } // set a = min(a,b)
template<typename T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }

template <int MOD>
struct ModInt {
    int val;
    // constructor
    ModInt(ll v = 0) : val(int(v % MOD)) {
        if (val < 0) val += MOD;
    };
    // unary operator
    ModInt operator+() const { return ModInt(val); }
    ModInt operator-() const { return ModInt(MOD - val); }
    ModInt inv() const { return this->pow(MOD - 2); }
    // arithmetic
    ModInt operator+(const ModInt& x) const { return ModInt(*this) += x; }
    ModInt operator-(const ModInt& x) const { return ModInt(*this) -= x; }
    ModInt operator*(const ModInt& x) const { return ModInt(*this) *= x; }
    ModInt operator/(const ModInt& x) const { return ModInt(*this) /= x; }
    ModInt pow(ll n) const {
        auto x = ModInt(1);
        auto b = *this;
        while (n > 0) {
            if (n & 1) x *= b;
            n >>= 1;
            b *= b;
        }
        return x;
    }
    // compound assignment
    ModInt& operator+=(const ModInt& x) {
        if ((val += x.val) >= MOD) val -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt& x) {
        if ((val -= x.val) < 0) val += MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt& x) {
        val = int(ll(val) * x.val % MOD);
        return *this;
    }
    ModInt& operator/=(const ModInt& x) { return *this *= x.inv(); }
    // compare
    bool operator==(const ModInt& b) const { return val == b.val; }
    bool operator!=(const ModInt& b) const { return val != b.val; }
    // I/O
    friend std::istream& operator>>(std::istream& is, ModInt& x) noexcept { return is >> x.val; }
    friend std::ostream& operator<<(std::ostream& os, const ModInt& x) noexcept { return os << x.val; }
};
using mint = ModInt<int(998244353)>;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin>>n>>m;
    mint ans=0;
    int M=m+n;
    vector<mint> fac(M+1), inv(M+1);
    fac[0]=1;
    for (int i=1; i<=M; i++) {
        fac[i]=fac[i-1]*i;
    }
    inv[M]=fac[M].inv();
    for (int i=M-1; i>=0; i--) inv[i]=inv[i+1]*(i+1);
    auto C=[&](int n, int m) -> mint {
        return fac[n]*inv[m]*inv[n-m];
    };
    for (int i=1; i<=m; i++) {
        mint tmp=1;
        int x=i;
        for (int f=2; f*f<=x; f++) {
            int cnt=0;
            while (x%f==0) x/=f, cnt++;
            tmp*=C(cnt+n-1, n-1);
        }
        if (x>1) 
            tmp*=C(1+n-1, n-1);
        ans+=tmp;
    }
    cout<<ans;
    return 0;
}

#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define endl '\n'

using namespace std;

const int mod = 998244353;

int add(int a, int b)
{
    a += b;
    if (a >= mod)
        a -= mod;

    return a;
}

int fast_pow(int x, int deg)
{
    int ans = 1, y = x;
    while (deg)
    {
        if (deg & 1)
            ans = 1ll * ans * y % mod;

        deg >>= 1;
        y = 1ll * y * y % mod; 
    }

    return ans;
}

int n, m; 
void read()
{
	cin >> n >> m; 
}

const int maxn = 2e5 + 3; 
const int maxlog = 20;

int fact[maxn], inv_fact[maxn];
void precompute()
{
    fact[0] = 1;
    for (int i = 1; i < maxn; i++)
        fact[i] = 1ll * fact[i-1] * i % mod;

    inv_fact[maxn-1] = fast_pow(fact[maxn-1], mod-2);
    for (int i = maxn-2; i >= 0; i--)
        inv_fact[i] = 1ll * inv_fact[i+1] * (i + 1) % mod;
}

int comb(int a, int b)
{
    if (b > a)
        return 0;

    return 1ll * fact[a] * inv_fact[b] % mod * inv_fact[a-b] % mod;
}


int f[maxn][maxlog];
vector <int> d[maxn];

void solve()
{
    precompute();

    for (int i = 1; i <= m; i++)
    for (int j = i + i; j <= m; j += i)
    d[j].push_back(i);

    f[1][1] = 1;
    for (int i = 2; i <= m; i++)
    {
        f[i][1] = 1;
        for (int j = 2; j < maxlog; j++)
            for (auto k: d[i])
                f[i][j] = add(f[i][j], f[k][j-1]);
    }

    int ans = 0;
    for (int i = 1; i <= m; i++)
    for (int j = 1; j < maxlog; j++)
        ans = add(ans, 1ll * f[i][j] * comb(n-1, j-1) % mod);

    cout << ans << endl; 
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	
	read();
	solve();
}
