#include<bits/stdc++.h>

using pii = std::pair<int, int>;

using i64 = long long;

static constexpr int mod = 998244353;

class combMath
{
public:
	static constexpr int size = 2e5;
	i64 fact[size + 1];
	i64 finv[size + 1];
	i64 inve[size + 1];
	static constexpr int mod = 998244353;
	void factor()
	{
		fact[0] = 1; fact[1] = 1;
		inv();
		finv[0] = 1;
		finv[1] = inve[1];
		for (int i = 2; i <= size; ++i) fact[i] = fact[i - 1] * i % mod, finv[i] = finv[i - 1] * inve[i] % mod;
	}
	void inv()
	{
		inve[1] = 1;
		for (int i = 2; i <= size; ++i)
		{
			inve[i] = (mod - mod / i) * inve[mod % i] % mod;
		}
	}
public:
	combMath() { factor(); }
	i64 power(i64 x, i64 p)
	{
		i64 temp = p, ans = 1;
		while (temp)
		{
			if (temp & 1) ans = ans * x % mod;
			temp >>= 1;
			x = x * x % mod;
		}
		return ans;
	}
	i64 getInv(i64 x)
	{
		return power(x, mod - 2);
	}
	i64 inv(i64 x)
	{
		return inve[x];
	}
	i64 facInv(i64 x)
	{
		return finv[x];
	}
	i64 getFac(i64 obj)
	{
		return fact[obj];
	}
	i64 perm(i64 n, i64 m, bool mode)
	{
		if (mode) return fact[n] * finv[n - m] % mod;
		else return fact[n] / fact[n - m];
	}
	i64 comb(i64 n, i64 m, bool mode)
	{
		if (mode) return fact[n] * finv[n - m] % mod * finv[m] % mod;
		else return fact[n] / fact[n - m] / fact[m];
	}
	i64 stirling(i64 n, i64 m) // 'n' balls into 'm' boxes, boxes DO NOT differ while balls differ.
	{
		i64 ans = 0;
		for (int i = 0; i < m; ++i)
			ans = (ans + (i & 1 ? -1 : 1) * comb(m, i, 1) * power(m - i, n) % mod) % mod;
		ans = ans * finv[m] % mod;
		return (ans + mod) % mod;
	}
	i64 catalan(int n, int mode) // n different nums pop in a stack in an certain order, how many ramifications there will be.
	{
		std::vector<i64> dp(n + 1, 1);
		if (mode) for (int i = 1; i <= n; ++i) dp[i] = dp[i - 1] * (4LL * i % mod - 2) % mod * inv(i + 1) % mod;
		else for (int i = 1; i <= n; ++i) dp[i] = dp[i - 1] * (4 * i - 2) / (i + 1);
		return dp[n];
	}
} cm;

void solve()
{
    int m, n;
    std::cin >> m >> n;
    i64 ans = cm.comb(m, n, 1) * n % mod;
    std::vector<std::vector<i64>> dp(m + 1, std::vector<i64>(25));
    for (int i = 1; i <= m; ++i)
    {
        dp[i][0] = 1;
        for (int j = i + i; j <= m; j += i)
        {
            for (int k = 0; k < 20; ++k)
            {
                dp[j][k + 1] = (dp[j][k + 1] + dp[i][k]) % mod;
            }
        }
    }
    // std::cout << ans << "\n";
    for (int i = 1; i <= m; ++i)
    {
        int r = m / i - 1;
        for (int j = 0; j <= 20; ++j)
        {
            int cnt = n - j - 1;
            if (cnt < 0) break;
            if (r >= cnt)
            {
                ans = (ans - dp[i][j] * cm.comb(r, cnt, 1) % mod + mod) % mod;
            }
        }
    }
    std::cout << ans << "\n";
}

int main()
{
    // int t;
    // std::cin >> t;
    // while (t--)
    // {
    //     solve();
    // }
    solve();

    return 0;
}