#include <bits/stdc++.h>
#define ll long long
#define PII pair<int,int>
#define PIII pair<int,PII>
#define PI4 pair<int,array<int,3>>
#define endl '\n'
#define int long long
#define LL __int128
#define  lc p<<1
#define  rc p<<1|1
using namespace  std;
const int N = 1e5 + 10,mod=998244353;
using i64 = long long;

template<class T> constexpr T mypow(T n, i64 k) {
	T r = 1;
	for (; k; k /= 2, n *= n) {
		if (k % 2) {
			r *= n;
		}
	}
	return r;
}

template<int MOD> struct Zmod {
	int x;
	Zmod(int x = 0) : x(norm(x % MOD)) {}
//	Zmod(i64 x) : x(norm(x % MOD)) {}
	
	constexpr int norm(int x) const {
		if (x < 0) {
			x += MOD;
		}
		if (x >= MOD) {
			x -= MOD;
		}
		return x;
	}
	constexpr int val() const {
		return x;
	}
	constexpr Zmod operator-() const {
		Zmod val = norm(MOD - x);
		return val;
	}
	constexpr Zmod inv() const {
		assert(x != 0);
		return mypow(*this, MOD - 2);
	}
	friend constexpr auto &operator>>(istream &in, Zmod &j) {
		int v;
		in >> v;
		j = Zmod(v);
		return in;
	}
	friend constexpr auto &operator<<(ostream &o, const Zmod &j) {
		return o << j.val();
	}
	constexpr Zmod &operator++() {
		x = norm(x + 1);
		return *this;
	}
	constexpr Zmod &operator--() {
		x = norm(x - 1);
		return *this;
	}
	constexpr Zmod &operator+=(const Zmod &i) {
		x = norm(x + i.x);
		return *this;
	}
	constexpr Zmod &operator-=(const Zmod &i) {
		x = norm(x - i.x);
		return *this;
	}
	constexpr Zmod &operator*=(const Zmod &i) {
		x = i64(x) * i.x % MOD;
		return *this;
	}
	constexpr Zmod &operator/=(const Zmod &i) {
		return *this *= i.inv();
	}
	constexpr Zmod &operator%=(const int &i) {
		return x %= i, *this;
	}
	friend constexpr Zmod operator+(const Zmod i, const Zmod j) {
		return Zmod(i) += j;
	}
	friend constexpr Zmod operator-(const Zmod i, const Zmod j) {
		return Zmod(i) -= j;
	}
	friend constexpr Zmod operator*(const Zmod i, const Zmod j) {
		return Zmod(i) *= j;
	}
	friend constexpr Zmod operator/(const Zmod i, const Zmod j) {
		return Zmod(i) /= j;
	}
	friend constexpr Zmod operator%(const Zmod i, const int j) {
		return Zmod(i) %= j;
	}
	friend constexpr bool operator==(const Zmod i, const Zmod j) {
		return i.val() == j.val();
	}
	friend constexpr bool operator!=(const Zmod i, const Zmod j) {
		return i.val() != j.val();
	}
	friend constexpr bool operator<(const Zmod i, const Zmod j) {
		return i.val() < j.val();
	}
	friend constexpr bool operator>(const Zmod i, const Zmod j) {
		return i.val() > j.val();
	}
};

constexpr int MOD[] = {998244353, 1000000007};
using Z = Zmod<MOD[0]>;

Z power(int n) {
	return mypow(Z(2), n);
}

bool isprime[N];
int prime[N];
int cnt;
void euler(int n) {
	memset(isprime, true, sizeof(isprime));
	isprime[1] = false;
	for (int i = 2; i <= n; ++i) {
		if (isprime[i]) prime[++cnt] = i;
		for (int j = 1; j <= cnt && i * prime[j] <= n; ++j) {
			isprime[i * prime[j]] = false;
			if (i % prime[j] == 0) break;
		}
	}
}
Z fac[N], inv[N];
void fact(int n) {
	fac[0] = 1;
	for (int i = 1; i <= n; i++) {
		fac[i] = fac[i - 1] * (i);
	}
	inv[n] = mypow(fac[n], mod - 2);
	for (int i = n - 1; i >= 0; i--) {
		inv[i] = inv[i + 1] * (i + 1);
	}
}
Z C(int n, int m) {
	if (m > n)return 0;
	return fac[n] * inv[m]* inv[n - m];
}
Z f[N][30];
void solve() {
	int n, m;
	cin>>m>>n;
	fact(m);
	Z ans;
	for(int i=1;i<=m;i++){
		f[i][1]=1;
	}
	for(int i=1;i<=m;i++){
		for(int j=i*2;j<=m;j+=i){
			for(int l=0;l<=20;l++){
				f[j][l+1]+=f[i][l];
			}
			
		}
	}
	ans=C(m,n)*Z(n);
//	cout<<ans<<endl;
	for(int i=1;i<=m;i++){
		for(int l=1;l<=20;l++){
			ans-=f[i][l]*C(m/i-1,n-l);
		}
	}
	cout<<ans<<endl;
}
signed main() {
//	ios::sync_with_stdio(false), cin.tie(0);
	ll t = 1;
//	cin >> t;
//	euler(1e3);
	while (t--) {
		solve();
	}
}