#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll mod = 998244353;
#define pival 3.14159265358979323846264338327950L
#define pll pair<ll,ll>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define pqq priority_queue
#define all(a) a.begin(), a.end()
#define sz(a) (ll)(a.size())
#define endl '\n'
#define DEBUG
#ifdef DEBUG
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1)
    {
        cerr << name << " = " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args)
    {
        const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " = " << arg1 << " || ";
        __f(comma+1, args...);
    }
#else
#define debug(...)
#endif
template <class Ch, class Tr, class Container>
basic_ostream <Ch, Tr> & operator << (basic_ostream <Ch, Tr> & os, Container const& x) {
    os << "{ ";
    for(auto& y : x) os << y << " ; ";
    return os << "}";
}
template <class X, class Y>
ostream & operator << (ostream & os, pair <X, Y> const& p) {
    return os << "[ " << p.first << ", " << p.second << "]" ;
}
ll power(ll x, ll y, ll p)
{
    ll res = 1;
    x = x % p;
    while (y > 0) {
        if (y & 1) res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}
const ll L = 5e5 + 5;
ll fact[L];
ll ncr (ll n, ll r) {
	if (n == 0 || n < r) return 0;
	ll t1 = fact[n];
	ll t2 = power(fact[n - r], mod - 2, mod);
	ll t3 = power(fact[r], mod - 2, mod);
	t1 = (t2 * t1) % mod;
	t1 = (t3 * t1) % mod;
	return t1;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    fact[0] = 1;
 	for (ll i = 1; i < L; i++) {
 		fact[i] = (fact[i - 1] * i) % mod;
 	}
 	ll n, k;
 	cin >> n >> k;
 	if (k == 1) {
 		cout << n << endl;
 		return 0;
 	}
 	ll ans = ncr(n - 1, k - 1);
 	for (ll i = 2; i <= n; i++) {
		ll c = n / i;
		ans = (ans + ncr(c - 1, k - 1)) % mod;
 	}
 	cout << ans << endl;
	return 0;
}

  #include <bits/stdc++.h>
    using namespace std;
    typedef unsigned long long ull ;
    typedef long long ll ;
    #define LONGMAX 1e18
    #define ll  long long
    //#define dd double
    //#define MOD 1000000007
    //#define nl cout<<endl
    //#define rt ll  Q[100005]={0}
    //#define mp make_pair
    #define endl "\n"
    #define test() ull  t;cin>>t;while(t--)
    //#define pb push_back
    //#define ff first
    //#define ss second
    //#define all (v) v.begin(),v.end()
    //#define s(ar,n) sort(ar,ar+n)
    //#define rs(ar,n) sort(ar, ar+n, greater<ll >())
    //#define oa(a,n) for(ll  i=0;i<n;i++)cout<<a[i]<<" ";nl
    #define cn(a,n) for(ll  i=0;i<n;i++)cin>>a[i];
    //#define ov(a,n) for(ll  i=n-1;i>=0;i--)cout<<a[i]<<" ";nl
    //#define maxa(ar,N) *max_element(ar,ar+N)
    //#define mina(ar,N) *min_element(ar,ar+N)
    //#define INF 1e9
    //#define setbitint(a) __builtin_popcount(a)
    //#define setbitll (a) __builtin_popcountll (a)
    //#define lb lower_bound
    //#define ub upper_bound
    //#define bs binary_search
    #define fastio() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
    //ll powe(ll n,ll m){if(m==0)return 1;ll t=powe(n,m/2);if(m%2==0)return (t*t);return (((t*t))*n);}
    //ll  mpowe(ll  n,ll  m){if(m==0)return 1;ll  t=powe(n,m/2);t%=MOD;if(m%2==0)return (t*t)%MOD;return (((t*t)%MOD)*n)%MOD;}
    //ll  logtwo(ll  n){if(n==1)return 0;return logtwo(n/2)+1;}
    //vocheck ceilsearch(ll  ar[],ll  low,ll  high,ll  x,ll  &y){ll  mcheck=(low+high)/2;if(low>high)return;if(ar[mcheck]>=x){y=mcheck;ceilsearch(ar,low,mcheck-1,x,y);}else{ceilsearch(ar,mcheck+1,high,x,y);}}

     #define mod 998244353
     #define inv 748683265

    ll power(ll x, ll y, ll p)
    {
    ll res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
ll modInverse(ll n, ll p)
{
    return power(n, p-2, p);
}

// Returns nCr % p using Fermat's little
// theorem.
ll nCrModPFermat(ll n, ll r, ll p)
{
   // Base case
   if (r==0)
      return 1;

    // Fill  factorial array so that we
    // can find all  factorial of r, n
    // and n-r
    ll fac[n+1];
    fac[0] = 1;
    for (ll i=1 ; i<=n; i++)
        fac[i] = fac[i-1]*i%p;

    return (fac[n]* modInverse(fac[r], p) % p *
            modInverse(fac[n-r], p) % p) % p;
}
    int main()
    {
        fastio();
        ll n,k;
        cin>>n>>k;
        ll  ans=0;
        if(k==1)
        {
        	cout<<n<<endl;
        	return 0;
        }
        for (int i=1;i<n;i++)
        {
            int count=n/i;
            if(count<k)
                break;
            ans+=nCrModPFermat(count-1,k-1,mod);
            ans%=mod;
        }
        cout<<ans<<endl;
    }

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <deque>
#include <bits/stdc++.h>
//#include "testlib.h"
using namespace std;
#define ll long long
#define pii pair<int,int>
#define qi ios::sync_with_stdio(0)

bool debug=true;

/*    *************************************
	  * Written in New Computer           *
	  * The following code belongs to     *
	  * XiaoGeNintendo of HellHoleStudios *
	  *************************************
*/
template<typename T1,typename T2>ostream& operator<<(ostream& os,pair<T1,T2> ptt){
	os<<ptt.first<<","<<ptt.second;
	return os;
}
template<typename T>ostream& operator<<(ostream& os,vector<T> vt){
	os<<"{";
	for(int i=0;i<vt.size();i++){
		os<<vt[i]<<" ";
	}
	os<<"}";
	return os;
}

int n,k;

ll fact[500005];
ll inv[500005];
const ll mod=998244353;

ll qp(ll a,ll b){
	if(b==0){
		return 1;
	}
	ll ans=qp(a,b/2);
	if(b%2){
		return ans*ans%mod*a%mod;
	}else{
		return ans*ans%mod;
	}
}

inline ll C(ll n,ll k){
	if(n-k<0){
		return 0;
	}
	return fact[n]*inv[k]%mod*inv[n-k]%mod;
}

int main(int argc,char* argv[]){
	cin>>n>>k;

	fact[0]=1;
	for(int i=1;i<=n;i++){
		fact[i]=fact[i-1]*i%mod;
	}

	for(int i=0;i<=n;i++){
		inv[i]=qp(fact[i],mod-2);
//		cout<<inv[i]<<" "<<factendl;
	}

	ll ans=0;
	for(int i=1;i<=n;i++){
//		cout<<n/i-1<<" "<<k-1<<" "<<C(n/i-1,k-1)<<endl;
		ans+=C(n/i-1,k-1);
		ans%=mod;
	}

	cout<<ans<<endl;
	return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stack>
#include <queue>
using namespace std;
#define sd(n) scanf("%d", &n)
#define sdd(n, m) scanf("%d%d", &n, &m)
#define sddd(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define pd(n) printf("%d\n", n)
#define pc(n) printf("%c", n)
#define pdd(n, m) printf("%d %d\n", n, m)
#define pddd(n, m, z) printf("%d %d %d\n", n, m, z)
#define pld(n) printf("%lld\n", n)
#define pldd(n, m) printf("%lld %lld\n", n, m)
#define plddd(n, m, z) printf("%lld %lld %lld\n", n, m, z)
#define sld(n) scanf("%lld", &n)
#define sldd(n, m) scanf("%lld%lld", &n, &m)
#define slddd(n, m, k) scanf("%lld%lld%lld", &n, &m, &k)
#define sf(n) scanf("%lf", &n)
#define sc(n) scanf("%c", &n)
#define sff(n, m) scanf("%lf%lf", &n, &m)
#define sfff(n, m, k) scanf("%lf%lf%lf", &n, &m, &k)
#define ss(str) scanf("%s", str)
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = a; i >= n; i--)
#define mem(a, n) memset(a, n, sizeof(a))
#define debug(x) cout << #x << ": " << x << endl
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define ce i == n ? '\n' : ' '
#define mod(x) ((x) % MOD)
#define gcd(a, b) __gcd(a, b)
#define lowbit(x) (x & -x)
typedef pair<int, int> PII;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
inline int read()
{
	int ret = 0, sgn = 1;
	char ch = getchar();
	while (ch < '0' || ch > '9')
	{
		if (ch == '-')
			sgn = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9')
	{
		ret = ret * 10 + ch - '0';
		ch = getchar();
	}
	return ret * sgn;
}
inline void Out(int a) //ê?3?ía1ò
{
	if (a > 9)
		Out(a / 10);
	putchar(a % 10 + '0');
}

ll gcd(ll a, ll b)
{
	return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b)
{
	return a * b / gcd(a, b);
}
///快速幂m^k%mod
ll qpow(ll x, ll n, ll mod)
{
	ll res = 1;
	while (n)
	{
		if (n & 1)
			res = (res * x) % mod;
		x = x * x % mod, n >>= 1;
	}
	return res;
}

const int N = 5e5 + 50;
int n, k;
const int mod = 998244353;
int F[N], Finv[N], inv[N]; //F是阶乘，Finv是逆元的阶乘

void init()
{
	inv[1] = 1;
	for (int i = 2; i < N - 10; i++)
	{
		inv[i] = (mod - mod / i) * 1ll * inv[mod % i] % mod;
	} //递推求逆元
	F[0] = Finv[0] = 1;
	for (int i = 1; i < N - 10; i++)
	{
		F[i] = F[i - 1] * 1ll * i % mod;
		Finv[i] = Finv[i - 1] * 1ll * inv[i] % mod;
	}
}

int comb(int n, int m) //comb(n, m)就是C(n, m)
{
	if (m < 0 || m > n)
		return 0;
	return F[n] * 1ll * Finv[n - m] % mod * Finv[m] % mod;
}

int main()
{
	int T;
	sdd(n, k);
	init();
	int ans = 0;
	rep(i, 1, n)
	{
		ans += comb(n / i - 1, k - 1) % mod;
		ans %= mod;
	}
	pd(ans);
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
typedef vector<int> vi;
#define pb push_back
typedef pair<int, int> pii;

const ll N = 5e5+50;
ll fact[N+1];
const ll mod = 998244353;
void find_fact(){
    fact[0] = 1;
    for(int i=1;i<=N;i++){
        fact[i] = (fact[i-1]*i)%mod;
    }
}

ll power(ll x, ll y){
    ll z = 1;
    while(y){
        if(y & 1)
        z = (z*x)%mod;
        x = (x*x)%mod;
        y >>= 1;
    }
    return z;
}

ll modInv(ll k){
    return power(k, mod-2);
}

ll nCr(ll n, ll r){
    ll temp = modInv((fact[n-r]*fact[r])%mod);
    return ((fact[n])*temp)%mod;
}

void solve(){
    find_fact();
    ll n,k;
    cin >> n >> k;
    ll ans = 0;
    for(int i=1;i<=n;i++){
        ll temp = (n/i);
        if(temp < k){
            break;
        }
        ans = (ans + nCr(temp-1, k-1))%mod;
    }
    cout << ans << "\n";
}

int main(){

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t=1;

    while(t--){
        solve();
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'

const int maxN = 500000;
const long long mod = 998244353;
vector<long long> pascal(maxN+1);

long long x, y, mcd;

void extendedEuclid(long long a, long long b){
	if(b == 0){
		x = 1;
		y = 0;
		mcd = a;
	}
	else{
		extendedEuclid(b, a % b);
		x = y;
		y = (mcd - a*x) / b;
	}
}

long long moduloDivision(long long a, long long b, long long modulo){
	extendedEuclid(b,modulo);
	if(x < 0)
	x += modulo;
	return (x * (a / mcd)) % modulo;
}

void precalcularPascal(int k){
	for(int i=0; i<=maxN; i++){
		if(i < k)
		pascal[i] = 0;
		else if(i == k)
		pascal[i] = 1;
		else{
			pascal[i] = (pascal[i-1] * i) % mod;
			pascal[i] = moduloDivision(pascal[i], i-k, mod);
		}
	}
}

int main(){
	ios_base::sync_with_stdio(0);cin.tie(NULL);
	int n,k,m,r;
	long long ans = 0;
	cin>>n>>k;
	r = k-1;
	precalcularPascal(r);
	for(int i=1; i<=n; i++){
		m = ((n-i) / i);
		if(m >= r)
		ans = (ans + pascal[m]) % mod;
	}
	cout<<ans<<endl;
}

#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ll;
//const double pi=acos(-1.0);
const ll N = 500043;
const ll MOD = 998244353;

ll fact[N];
#define forn(i,k,n) for(ll i=k;i<n;i++)
#define fornr(i,k,k1) for(ll i=k;i>=k1;i--)
#define v(ll) vector<ll>
#define vl(a,n,ll,k) vector<ll> a(n,k)
#define vli(a,n) vector<ll> a(n)
#define init(a,n) vector<ll> a(n);forn(i,0,n)cin>>a[i]
#define vll(a,n,m,ll,k) vector<vector<ll>> a(n,vector<ll>(m,k))
#define mp(a,ll,ll1) map<ll,ll1> a
#define st(a,ll) set<ll> a
#define mpa make_pair
#define pr pair<ll,ll>
#define pb push_back
#define MAX 1000000
#define ed '\n'
#define fileTake ifstream cin("input.txt");ofstream cout("output.txt");
#define sortv(a) sort(a.begin(),a.end())
#define sorta(a,n) sort(a,a+n)
#define yeah "YES"
#define nil "NO"
#define All(x) x.begin(),x.end()
#define remDup(a) a.erase(unique(All(a)),a.end())

void swap(ll &x,ll &y)
{
	x=x^y;
	y=x^y;
	x=x^y;
}

template<typename T>
void print(T a){for(auto i=a.begin();i!=a.end();i++)cout<<*i<<" ";cout<<endl;}
bool isVowel(char c)
{
	if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u')return true;
	return false;
}

void sync(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
ll power(ll a,ll b){
    ll ans=1;
    while(b>0){
        if(b&1){ans=(ans*a)%MOD;}
                a=(a*a)%MOD;
                b>>=1;
        }
    return ans;

}
ll inv(ll x)
{
	return power(x, MOD - 2);
}
ll mul(ll x, ll y)
{
	return (x * 1ll * y) % MOD;
}
ll divide(ll x, ll y)
{
	return mul(x, inv(y));
}

void pre()
{
	fact[0] = 1;
	for(ll i = 1; i < N; i++)
		fact[i] = mul(i, fact[i - 1]);
}

ll C(ll n, ll k)
{
	if(k > n) return 0;
	return divide(fact[n], mul(fact[n - k], fact[k]));
}

int main(){
	sync();
	pre();
	ll n,k;
	cin>>n>>k;
	ll ans=0;
	forn(i,1,n+1)
	{
		ll x=n/i;
		ans+=C(x-1,k-1);
		ans%=MOD;
	}
	cout<<ans<<endl;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define debug(x) cout << ">>" << #x << ':' << x << endl;
#define endl "\n"
#define pb push_back
#define fo(i,n) for(int i=0 ; i<n ; i++)

const int MOD = 998244353;
const int MAXN = 500001;

int fact[MAXN];

void calc_fact(int n = MAXN-1) {
    fact[0] = 1;
    for(int i = 1; i <= n; i++) fact[i] = (i * 1LL * fact[i-1]) % MOD;
}

//fast exponentiation / binary exponentiation
int fast_pow(int n, int k) {
    int res = 1;
    while(k > 0) {
        if(k % 2) res = (res * 1LL * n) % MOD;
        n = (n * 1LL * n) % MOD;
        k /= 2;
    }
    return res;
}

int inv_mod(int n) {
    return fast_pow(n, MOD-2);
}

int NcR (int n, int k) {
    if(k > n) return 0;
    return ((fact[n] * 1LL * inv_mod(fact[k])) % MOD * inv_mod(fact[n-k])) % MOD;
}

int main()
{
	ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n , k;
	cin>>n>>k;

	calc_fact(n);

	int ans = NcR(n-1 , k-1);
	for(int i=2 ; i<=n ; i++)
	{
		int div = n/i;

		if(div < k)
		{
			break;
		}
		else
		{
			ans += NcR(div-1 , k-1);
			ans = ans%MOD;
		}
	}
	ans = ans%MOD;
	cout<<ans<<endl;

}

#include <bits/stdc++.h>
using namespace std;

#define int long long
#define mod 998244353

int fact[500005];

int pr(int x, int y) {
    int res = 1;
    x = x % mod;
    while (y > 0){
        if (y & 1)
            res = (res*x) % mod;
        y >>= 1;
        x = (x*x) % mod;
    }
    return res;
}
int f2(int i, int j){
    if(i > j)return 0;
    int ret = (fact[j] * pr(fact[j - i] * fact[i], mod - 2))% mod;
    return ret;
}

// int f(int n, int c){
//     if(n == 1){
//         return c;
//     }
//     int ret = 0;
//     for(int i = 1; i <= c - 1; i++){
//         ret += f(n-1, i);
//     }
//     return ret;
// }

signed main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    fact[0] = 1;
    for(int i = 1; i < 500005; i++){
        fact[i] = (i * fact[i-1]) % mod;
    }
    // for(int i = 1; i < 10; i++){
    //     for(int j = 1; j < 10; j++){
    //         cout << i << ' ' << j << ' ' << f(i, j) << f2(i, j) << '\n';
    //     }
    //     // cout << '\n';
    // }
    int n, k;
    cin >> n >> k;
    int ans = 0;
    if(k == 1){
        cout << n << '\n';
        return 0;
    }
    for(int i = 1; i < n; i++){
        int c = 0;
        for(int j = 2; i * j <= n; j++){
            c++;
        }
        // a1 = i, a2 - an among c numbers
        ans += f2(k - 1, c);
        ans %= mod;
    }
    cout << ans << '\n';
}

#include<bits/stdc++.h>
#define endl '\n'
#define null NULL
#define ls p<<1
#define rs p<<1|1
#define fi first
#define se second
#define mp make_pair
#define pb push_back
//#define ll long long
#define int long long
#define pii pair<int,int>
#define ull unsigned long long
#define all(x) x.begin(),x.end()
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ct cerr<<"Time elapsed:"<<1.0*clock()/CLOCKS_PER_SEC<<"s.\n";
char *fs,*ft,buf[1<<20];
#define gc() (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<20,stdin),fs==ft))?0:*fs++;
inline int read(){int x=0,f=1;char ch=gc();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=gc();}
return x*f;}
using namespace std;
const int N=1e6+5;
const int inf=0x7fffffff;
const int mod=998244353;
const double eps=1e-6;
const double PI=acos(-1);
int a[N];
void pp(int n,int k)
{
	a[1]=n-1;
	for(int i=2;i*k<=n;i++)
		a[i]=n/i-1;
}
int qpow(int a,int b)
{
	int ans=1;
	while(b)
	{
		if(b&1)
			ans=(ans*a)%mod;
		a=a*a%mod;
		b>>=1;
	}
	return ans;
}
int fun(int x,int k)
{
	int i,sum=1;
	for(i=a[x];i>a[x]-k;i--)
		sum=(sum*i)%mod;
	for(i=2;i<=k;i++)
		sum=sum*qpow(i,mod-2)%mod;
	return sum;
}
signed main()
{
	int n,k,ans=0;
	cin>>n>>k;
	if(n<k)
		cout<<0<<endl;
	else
	{
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
	    swap(n,k);
		pp(n,k);
		for(int i=1;i*k<=n;i++)
			ans=(ans+fun(i,k-1))%mod;
		cout<<ans<<endl;
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

const double pi = acos(-1.0);
typedef long long ll;

ll n, k;

const int MOD = 998244353;
const int N = 5e5 + 5;

int f[N], inv[N], finv[N];
// inv[]: inverse element

int powMod(int u, int v) {
    int res = 1;
    while (v) {
        if (v & 1) res = (ll)res * u % MOD;
        v >>= 1;
        u = (ll) u * u % MOD;
    }
    return res;
}

void initInv() {
    f[0] = 1;
    for (int i = 1; i < N; i++) {
        f[i] = (ll)f[i - 1] * i % MOD;
    }
    inv[0] = inv[1] = 1;
    for (int i = 2; i < N; i++) {
        inv[i] = (ll)(MOD - MOD / i) * inv[MOD % i] % MOD;
    }
    finv[0] = finv[1] = 1;
    for (int i = 2; i < N; i++) {
        finv[i] = ((ll)finv[i - 1] * inv[i]) % MOD;
    }
}

int C(int x, int y) {
    if (y < 0) return 0;
    return ((ll)f[x] * finv[y] % MOD) * finv[x - y] % MOD;
}

int Lucas(int u, int v) {
    if (v == 0) return 1;
    return (ll)C(u % MOD, v % MOD) * Lucas(u / MOD, v / MOD) % MOD;
}

int main() {
    ios::sync_with_stdio(false);
    initInv();
    cin >> n >> k;
    int ans = 0;
    for (int x1 = 1; x1 <= n; x1++) {
        int multiples = n / x1 - 1;
        if (multiples < k - 1) continue;
        ans = (ans + C(multiples, k - 1)) % MOD;
    }
    cout << ans << endl;
    return 0;
}

#pragma GCC optimize("Ofast","inline","-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<bits/stdc++.h>
using namespace std;
using ll = long long ;
const ll mod =998244353 ;
const ll maxN = 5e5 + 10;
ll fact[maxN], invfact[maxN], inv[maxN];
ll mult(ll a, ll b)
{
    return (a * b) % mod;
}
ll com(ll n,ll k)
{
    return mult(fact[n], mult(invfact[k], invfact[n - k]));
}
void init()
{
    fact[0] = invfact[0] = fact[1] = invfact[1] = inv[1] = 1;
    for (ll i = 2; i < maxN; i++)
    {
        fact[i] = mult(fact[i - 1], i);
        inv[i] = mult(inv[mod % i], mod - mod / i);
        invfact[i] = mult(invfact[i - 1], inv[i]);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    init();
    ll n,k,ans=0;
    cin>>n>>k;
    for(ll i=1; i<=n/k; ++i)
        ans=(ans+com(n/i-1,k-1))%mod;
    cout<<ans;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define fi first
#define se second
#define endl '\n'
#define int int64_t
#define double long double
mt19937 rnd(time(0));
// back to back like I'm Jordan 96 97
// const int MAXN = 1002;
const int INF = numeric_limits<int>::max() >> 2;
// const int MOD = (int)1e9 + 7;
namespace Math{
  const int MAXN = 500005;
  int fac[MAXN], ifac[MAXN];
  const int MOD = 998244353;
  int Add(int a, int b){
    a += b;
    a %= MOD;
    return a < 0 ? a + MOD: a;
  }
  int Mul(int a, int b){
    return a*b%MOD;
  }
  int Pow(int a, int b) {
    int res = 1;
    while (b > 0) {
      if (b & 1) res = Mul(res, a);
      a = Mul(a, a);
      b >>= 1;
    }
    return res;
  }
  void Setup(){
    fac[0] = fac[1] = 1;
    for(int i = 2 ; i < MAXN ; i ++)
      fac[i] = Mul(fac[i - 1], i);
    ifac[MAXN - 1] = Pow(fac[MAXN - 1], MOD - 2);
    for(int i = MAXN - 2 ; i >= 0 ; i --)
      ifac[i] = Mul(ifac[i + 1], i + 1);
  }
  int C(int a, int b){
    if(a > b) return 0;
    return Mul(fac[b], Mul(ifac[a], ifac[b - a]));
  }
  int A(int a, int b){
    if(a > b) return 0;
    return Mul(fac[b], ifac[b - a]);
  }
  int StirlingII(int k, int n){
    int res = 0;
    for(int j = 0; j <= k; j ++)
      res = Add(res, (j%2 == 0 ? 1: -1)*Mul(C(j, k), Pow(k - j, n)));
    return Mul(res, ifac[k]);
  }
}
using namespace Math;
signed main(){
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // freopen("FDT.txt","r",stdin);
  int n, k;
  cin >> n >> k;
  if(k == 1){
    cout << n;
    return 0;
  }
  Setup();
  int ans = 0;

  for(int i = 1; i <= n; i ++){
    // fix first
    ans = Add(ans, C(k - 1, n/i - 1));
  }
  cout << ans;
  return 0;
}
/*
h*(a + 1) + c*a /(2a + 1) < t ?

*/

#include <bits/stdc++.h>
using namespace std;
/* * * *   * * *   	* * * */
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define ms(a,v) memset(a,v,sizeof a)
/* * * *   * * *   	* * * */
/* *
 *
 * I love Ylva Eriksson
 *
 * */
const ll mod =  998244353;
ll powmod(ll b, ll e){
	if(e == 0) return 1%mod;
	ll u = powmod(b, e/2);
	u = (u*u)%mod;
	if(e&1ll) u = (u*b)%mod;
	return u%mod;
}
ll solve(ll n, ll k, vector<ll>& fact){
	if(n < k) return 0;
	ll num = fact[n], den = (fact[n-k]*fact[k])%mod;
	return (num*powmod(den, mod-2))%mod;
}
int main(){
	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	ll n, k; cin>>n>>k;
	vector<ll> fact(5e5+10);
	fact[0] = 1;
	for(ll i = 1; i<5e5+10; ++i) fact[i] = (fact[i-1]*i)%mod;
	ll ans = 0;
	for(ll i = 1; i<=n; ++i){
		ans = (ans + solve(n/i - 1, k - 1, fact))%mod;
	}
	cout<<ans<<endl;
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ios ios_base::sync_with_stdio(0);cin.tie(0)
#define scn(n) scanf("%d",&n)
#define lscn(n) scanf("%lld",&n)
typedef long long ll;
#define pri(n) printf("%d\n",n)
#define lpri(n) printf("%lld\n",n);
#define rep(i,st,ed) for(int i=st;i<ed;i++)
#define var(n) int n; scn(n)
#define F first
#define S second
#define pb(n) push_back(n)
#define pii pair<int,int>
const int N=1e6+6;
const ll M = 998244353;
const ll inf=1e18+5;

ll fact[N];
ll power(ll b, ll p)
{
	if(p==0)
		return 1;
	if(p%2==0)
		return (power((b*b)%M,p/2))%M;
	return (b*power((b*b)%M,p/2))%M;
}
ll modinv(ll n)
{
	n%=M;
	ll ret =  power(n,M-2);
	return ret;
}
ll ncr(int n,int r)
{
	if(n<r)
		return 0;
	ll res = fact[n];
	res = (res * modinv(fact[r]))%M;
	res = (res * modinv(fact[n-r]))%M;
	return res;
}

void init()
{
	fact[0] = fact[1] = 1;
	for(int i=2;i<N;i++)
		fact[i] = (1ll*fact[i-1]*i)%M;
}
int main()
{
	init();

	var(n);var(k);
	if(n<k)
		pri(0);
	else if(n==k)
		pri(1);
	else
	{
		ll ans = 0;
		for(int i = 1;i<=n;i++)
		{
			int m = n/i;
			ll res = ncr(m-1,k-1);
			if(res==0)
				break;
			ans = (ans+res)%M;
		}
		lpri(ans);
	}
}

#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;
typedef long long ll;
typedef long double ld;
long double pi = 2 * acos(0.0);
const ll mod = 998244353;

ll fact(ll x) {
    if(x == 0 || x == 1) return 1;
    else return (x * fact(x - 1)) % mod;
}

ll modpow(ll a, ll x) {
    ll res = 1;
    while(x > 0) {
        if(x & 1) {res = (res * a) % mod;}
        x /= 2;
        a = (a * a) % mod;
    }
    return res;
}

ll modinv(ll x) {
    return modpow(x, mod - 2);
}

ll ncr(ll n, ll r) {
    if(r > n) return 0;
    if(r == 0) return 1;
    return (fact(n) * modinv((fact(r) * fact(n - r)) % mod)) % mod;
}

void solve() {
    ll n, k;
    cin >> n >> k;
    ll ans = 0;
    for(ll i = 1; i <= n; i++) {
        ll mul = n / i;
        ans = (ans + ncr(mul - 1, k - 1)) % mod;
    }
    cout << ans;
}

int main() {
    ios_base :: sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    //cin >> t;
    while(t--) {
        solve();
    }
    return 0;
}

#include<iostream>
#include<fstream>
#include<string>
#include<vector>
#include<list>
#include<set>
#include<map>
#include <algorithm>
#include <cstring>
#include<unordered_map>
#include <unordered_set>
#include<queue>

#include <iomanip>
#include <math.h>

typedef long long li;
using namespace std;
#define pas system("pause")

const int N = 998244353;
#define PI 3.141592653589793l

int bin_pow(int x, int y) {
	int z = 1;
	while (y > 0) {
		if (y % 2 == 1)
			z = (z *1ll* x) % N;
		x = (x *1ll* x) % N;
		y /= 2;
	}
	return z;
}

int main() {
	std::ios::sync_with_stdio(false);
	//ifstream cin("in.txt");
	//ofstream cout("out.txt");

	int n, k;
	cin >> n >> k;
	if (k > n) {
		cout << 0 << endl;
	}
	else {
		int right = n / k;
		int c = 1, ans = 0;
		int down = 1;
		for (int count_pos = k; count_pos <= n; count_pos++) {
			int left = n / (count_pos + 1);

			int count = right - left;
			right = left;
			ans += (c *1ll* count) % N;
			ans = ans % N;
			c = ((c *1ll* count_pos) % N * bin_pow(down++, N - 2)) % N;
		}
		cout << ans << endl;
	}

}

#include <bits/stdc++.h>

// definitions
#define f first
#define s second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define rep(i, l, r) for (long long i = (l); i < (long long)(r); i++)
#define repb(i, r, l) for (long long i = (r); i > (long long)(l); i--)
#define high(x) __builtin_popcountll(x)
#define pb push_back
#define pf push_front
#define mod1 998244353
#define mod 1000000007
#define MAX_CHAR 256
#define pi 3.1415926535897932384

using namespace std;
typedef vector<long long> vl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector< pair<long long, long long> > vp;
typedef vector<tuple<long long , long long , long long> > vtup;
typedef deque <long long> dql;
typedef deque <char> dqc;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;

ll INF=1e18;

// prevent collisions in unordered_map
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

template <class T>
void read(T arr[],ll n) {rep(i,0,n) cin>> arr[i];}

typedef unordered_map <long long, long long, custom_hash> umap;

// standard functions
ll mystoi(string str)
{
    stringstream ss(str);
    ll ans=0;
    ss >> ans;

    return ans;
}

ll exp(ll x, ll ex) {
    ll ans = 1ll;
    while (ex > 0) {
        if (ex & 1ll) ans = (ans * x)%mod1;
        ex >>= 1ll;
        x = (x * x)%mod1;
    }
    return ans;
}

ll fact[(ll)5e5+43];
ll add(ll x, ll y)
{
    x += y;
    while(x >= mod1) x -= mod1;
    while(x < 0) x += mod1;
    return x;
}
ll mul(ll x, ll y)  {   return (x * 1ll * y) % mod1;    }
ll inv(ll x)    {   return exp(x, mod1 - 2);     }
ll divide(ll x, ll y)   {  return mul(x, inv(y));  }

void precalc()
{
    fact[0] = 1;
    rep(i,1,5e5+43)
        fact[i] = mul(i, fact[i - 1]);
}

ll nCr(ll n, ll k)
{
    if(k > n) return 0;
    return divide(fact[n], mul(fact[n - k], fact[k]));
}

bool sort_cond(const pair<ll,ll> &a, const pair <ll,ll> &b)
{
    return a.first < b.first;
}

// code beigns in main
int main()
{

    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    ll t=1;
    // cin >> t;
    precalc();
    while(t--)
    {
        ll n,k;
        cin >> n >>k;
        ll ans=0;
        rep(i,1,n+1)
        {
            ll temp=nCr(n/i-1,k-1);
            temp%=mod1;
            ans+=temp;
            ans%=mod1;
        }

        cout << ans << endl;
    }
}

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define rt return 0
#define endln "\n"
#define all(v) v.begin(), v.end()
#define for1(i, a, b) for (long long int i = a; i < b; i++)
#define for2(i, a, b) for (long long int i = a; i > b; i--)
//  cout << fixed << setprecision(0) << pi <<" "<<npi<<endl;typedef long long int i;
typedef long long int lli;
typedef pair<lli, lli> pll;
lli gcdExtended(lli a, lli b, lli *x, lli *y);

// Function to find modulo inverse of b. It returns
// -1 when inverse doesn't
lli modInverse(lli b, lli m)
{
    lli x, y; // used in extended GCD algorithm
    lli g = gcdExtended(b, m, &x, &y);

    // Return -1 if b and m are not co-prime
    if (g != 1)
        return -1;

    // m is added to handle negative x
    return (x % m + m) % m;
}

// Function to compute a/b under modlo m
lli modDivide(lli a, lli b, lli m)
{
    a = a % m;
    lli inv = modInverse(b, m);
    // cout << inv << endl;
    lli y = (inv * a) % m;
    return y;
}

// C function for extended Euclidean Algorithm (used to
// find modular inverse.
lli gcdExtended(lli a, lli b, lli *x, lli *y)
{
    // Base Case
    if (a == 0)
    {
        *x = 0, *y = 1;
        return b;
    }

    lli x1, y1; // To store results of recursive call
    lli gcd = gcdExtended(b % a, a, &x1, &y1);

    // Update x and y using results of recursive
    // call
    *x = y1 - (b / a) * x1;
    *y = x1;

    return gcd;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    lli n, k, m = 998244353;
    cin >> n >> k;
    vector<lli> fac;
    vector<lli> modi;

    fac.pb(1);
    modi.pb(1);
    for1(i, 1, 500005)
    {
        lli x = fac[i - 1] * i;
        x %= m;
        fac.pb(x);
        lli y = modInverse(x, m);
        modi.pb(y);
    }
    // cout << fac[100000];
    if (k == 1)
    {
        cout << n << endl;
        rt;
    }
    if (k > n)
    {
        cout << "0" << endl;
        rt;
    }
    lli ans = 0;
    for1(i, 1, n)
    {
        lli x1 = i;
        lli y = n / x1;
        y -= 1;
        if (k - 1 > y)
        {
            break;
        }
        lli a = fac[y];
        a *= modi[k - 1];
        a %= m;
        a *= modi[y - k + 1];
        a %= m;
        // a = modDivide(a, fac[k - 1], m);
        // a = modDivide(a, fac[y - k + 1], m);
        // cout << a << endl;
        ans += a;
        ans %= m;
    }
    // lli ans = fac[n - 1];

    // ans = modDivide(ans, fac[k - 1], m);
    // // cout << ans << endl;
    // // cout << fac[k - 1] << endl;
    // ans = modDivide(ans, fac[n - k], m);
    // // cout << ans << endl;
    // lli x2 = n / 2;
    // x2 -= 1;
    // if (x2 >= k - 1)
    // {
    //     lli a2 = fac[x2];
    //     a2 = modDivide(a2, fac[k - 1], m);
    //     a2 = modDivide(a2, fac[x2 - k + 1], m);
    //     ans += a2;
    //     ans %= m;
    // }
    cout << ans << endl;
}

#include <bits/stdc++.h>
#define int long long
using namespace std;

typedef long long ll;
const int N = 1000100, MOD = 998244353;

int fact[N], infact[N];

int qmi(int a, int k, int p) {
	int res = 1;
	while (k) {
		if (k & 1) res = (ll)res * a % p;
		a = (ll)a * a % p;
		k >>= 1;
	}
	return res;
}

ll C(int a, int b) {
   return (ll)fact[a] * infact[b] % MOD * infact[a - b] % MOD;
}

int32_t main() {
	fact[0] = infact[0] = 1;
	for (int i = 1; i < N; i++) {
		fact[i] = (ll)fact[i - 1] * i % MOD;
		infact[i] = (ll)infact[i - 1] * qmi(i, MOD  - 2, MOD) % MOD;
	}
   	int n, k;
  	cin >> n >> k;
  	ll ans = 0;
	for (int i = 1; i * k <= n; i++) ans = (ans + C(n / i - 1, k - 1)) % MOD;
	cout << ans << endl;
  	return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define MAX 1000005
#define P 998244353
using namespace std;

ll n, k;
ll fac[MAX], inv[MAX];

void init(int n){
    fac[0] = 1, inv[0] = inv[1] = 1;
    for(int i = 1; i <= n; i++) fac[i] = fac[i-1]*i%P;
    for(int i = 2; i <= n; i++) inv[i] = (P-P/i)*inv[P%i]%P;
    for(int i = 2; i <= n; i++) inv[i] = inv[i]*inv[i-1]%P;
}

ll C(ll n, ll m){
    if(!m) return 1;
    return fac[n]*inv[m]%P*inv[n-m]%P;
}

int main()
{
    init(MAX-1);
    cin >> n >> k;
    ll ans = 0;
    for(int i = 1; i <= n; i++){
        if(n/i < k) break;
        ans = (ans+C(n/i-1, k-1))%P;
    }
    cout << ans << endl;

    return 0;
}

#include<bits/stdc++.h>

using namespace std;

const long long mod = 998244353;
long long fact[500005], inv[500005], invfact[500005], n, k, ans = 0;

inline long long choose(long long n, long long k){
    return (((fact[n] * invfact[k]) % mod) * invfact[n - k]) % mod;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    fact[0] = inv[0] = invfact[0] = fact[1] = inv[1] = invfact[1] = 1;
    for(long long i = 2; i < 500005; i++){
        fact[i] = (fact[i - 1] * i) % mod;
        inv[i] = (inv[mod % i] * (mod - mod / i)) % mod;
        invfact[i] = (inv[i] * invfact[i - 1]) % mod;
    }
    cin >> n >> k;
    for(int i = 1; i <= n; i++){
        if(n / i >= k){
            ans += choose(n / i - 1, k - 1);
            ans %= mod;
        }
    }
    cout << ans << '\n';
}

#include<bits/stdc++.h>
#define rgt register
#define rint rgt int
#define LL long long
#define rll rgt LL
#define inf 0x7f7f7f7f
#define N 500007
using namespace std;
const int p=998244353;
template<class K>inline bool cmax(K&a,const K&b){return(a<b)?a=b,1:0;}
template<class K>inline bool cmin(K&a,const K&b){return(a>b)?a=b,1:0;}
inline int read() {
	rgt int s=0;
	rgt char c=getchar();
	while(!isdigit(c)) c=getchar();
	while(isdigit(c)) s=(s<<1)+(s<<3)+c-'0',c=getchar();
	return s;
}
int n,k,mul[N],inv[N],ans;
inline int C(rint n,rint m) {
	return (LL)mul[n]*inv[m]%p*inv[n-m]%p;
}
inline int dec(rint x){return x>=p?x-p:x;}
int main() {
	rint i,c;n=read(),k=read()-1;
	if(n<k) {printf("0");return 0;}
	mul[0]=mul[1]=inv[1]=inv[0]=1;
	for(i=2;i<=n;i++) inv[i]=(LL)(p-p/i)*inv[p%i]%p;
	for(i=2;i<=n;i++)
		mul[i]=(LL)mul[i-1]*i%p,
		inv[i]=(LL)inv[i]*inv[i-1]%p;
	for(i=1;i<=n;i++) {
		c=n/i-1;if(c<k) break;
		ans=dec(ans+C(c,k));
	}printf("%d",ans);
	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <iomanip>
#include <string>
#include <sstream>
#include <cstdio>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <unordered_map>
#include <stack>
#include <stdio.h>
#include <assert.h>
using namespace std;

typedef long long LL;
typedef pair<LL, LL> pll;
typedef pair<int, LL> pil;
typedef pair<int, int> pii;
const int maxn = 5e5 + 100;
const int inf = 1e9 + 7;
const LL mod = 998244353;
int a[maxn];

/* Modular multiplication */
LL mul(LL x, LL y) {
	return (x*y) % mod;
}

/* Modular power */
LL pw(LL n, LL k) {
	if (k == 0) {
		return 1;
	}
	if (k % 2 == 0) {
		return pw(mul(n, n), k/2);
	} else {
		return mul(n, pw(n, k-1));
	}
}

/* Modular inverse - euler's formula */
LL inv(LL x) {
	return pw(x, mod-2);
}

/* Prepare factorials */
LL fac[maxn];
LL inv_fac[maxn];
void prepare_factorials() {
	fac[0] = inv_fac[0] = 1;
	for (int i = 1; i < maxn; i++) {
		fac[i] = 1LL * i * fac[i-1] % mod;
		inv_fac[i] = inv(fac[i]);
	}
}

/* Choose function (in linear time) */
LL choose(LL n, LL k) {
	if (n < 0 || k < 0 || k > n) return 0;
	LL cur = fac[n];
	cur = mul(cur, inv_fac[k]);
	cur = mul(cur, inv_fac[n-k]);
	return cur;
}

int main() {
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	int n, k;
	cin >> n >> k;
	prepare_factorials();
	if (k == 1) {
		cout << n << endl;
		return 0;
	}
	// k numbers has to be a multiple of the first one
	LL ans = 0;
	for (int first = 1; first <= n / k; first++) {
		// how many > first that are multiples of first <= n
		// floor(n / first) - 1
		LL nothers = 1LL * (n / first - 1);
		if (nothers < k-1) {
			continue;
		}
		// cout << "choose " << nothers << " " << k - 1 << " = " << choose(nothers, k-1) << endl;
		ans += choose(nothers, k-1);
		ans %= mod;
	}
	cout << ans << endl;
}

#pragma GCC optimize(2)
#pragma G++ optimize(2)
#include<bits/stdc++.h>
#define si(a) scanf("%d",&a)
#define sl(a) scanf("%lld",&a)
#define sd(a) scanf("%lf",&a)
#define ss(a) scanf("%s",a)
#define ms(a) memset(a,0,sizeof(a))
#define repi(i,a,b) for(register int i=a;i<=b;++i)
#define repd(i,a,b) for(register int i=a;i>=b;--i)
#define reps(s) for(int i=head[s],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define ce(i,r) i==r?'\n':' '
#define pb push_back
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define pr(x) cout<<#x<<": "<<x<<endl
using namespace std;
typedef long long ll;
const int MAX_N=5e5+5;
const ll mod=998244353;
ll fac[MAX_N],inv[MAX_N];
ll qpow(ll x,ll n,ll mod){ ll res=1;while(n){ if(n&1) res=(res*x)%mod; x=x*x%mod,n>>=1; } return res; }
ll Fermat(ll a,ll mod){return qpow(a,mod-2,mod);}
void init(int n,ll mod)
{
	fac[0]=1;
	repi(i,1,n) fac[i]=fac[i-1]*i%mod;
	inv[n]=Fermat(fac[n],mod);
	repd(i,n-1,0) inv[i]=inv[i+1]*(i+1)%mod;
}
ll C(ll n, ll m)
{
	return fac[n]*inv[n-m]%mod*inv[m]%mod;
}
int main()
{
	ll n,k; sl(n),sl(k);
	init(n,mod);
	ll ans=0;
	repi(i,1,n){
		ll tmp=n/i-1;
		if(tmp>=(k-1)) ans=(ans+C(tmp,k-1))%mod;
	}
	printf("%lld\n",(ans%mod+mod)%mod);
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=998244353;
const int maxn=5e5+5;
inline int read(){
	char c=getchar();int t=0,f=1;
	while((!isdigit(c))&&(c!=EOF)){if(c=='-')f=-1;c=getchar();}
	while((isdigit(c))&&(c!=EOF)){t=(t<<3)+(t<<1)+(c^48);c=getchar();}
	return t*f;
}
int n,k,ans;
inline int am(int a,int b){
	return a+b>=mod?a+b-mod:a+b;
}
int inv[maxn],rec[maxn];
inline int C(int a,int b){
	if(a<b)return 0;
	return rec[a]*inv[b]%mod*inv[a-b]%mod;
}
inline int get(int x){
	int m=n/x;
	return C(m-1,k-1);
}
inline int ksm(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=ans*a%mod;
		a=a*a%mod;b>>=1;
	}
	return ans;
}
signed main(){
	n=read(),k=read();
	rec[0]=inv[0]=1;
	for(int i=1;i<=n;i++){
		rec[i]=rec[i-1]*i%mod;
	}
	inv[n]=ksm(rec[n],mod-2);
	for(int i=n-1;i>=1;i--)inv[i]=inv[i+1]*(i+1)%mod;
	for(int i=1;i<=n;i++)
	ans=am(ans,get(i));
	printf("%d\n",ans);
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int Mod = 998244353;
ll add(ll a, ll b) {
    return (a + b) % Mod;
}
ll sub(ll a, ll b) {
    return (a + Mod - b) % Mod;
}
ll mul(ll a, ll b) {
    return (a * b) % Mod;
}
ll pwr(ll a, ll p) {
    ll res = 1;
    while (p) {
        if (p & 1) res = mul(res, a);
        a = mul(a, a);
        p >>= 1;
    }
    return res;
}
ll inv(ll a) {
    return pwr(a, Mod - 2);
}
ll divide(ll a, ll b) {
    return mul(a, inv(b));
}
ll C(ll n, ll k) {
    ll res = 1;
    for (ll i = 1; i <= k; i++)
        res = divide(mul(res, add(sub(n, k), i)), i);
    return res;
}

int main() {
    ll n, k;
    cin >> n >> k;

    ll ans = 0;
    for (ll i = 1; i * k <= n; i++)
        ans = add(ans, C(n / i - 1, k - 1));

    cout << ans << endl;

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll mod = 998244353;
const ll length = 500005;

ll ff[length];

ll inverse(ll x)
{
    ll res = 1;
    ll z = mod-2;
    while(z)
    {
        if(z&1)res = (res*x)%mod;
        x = (x*x)%mod;
        z >>= 1;
    }
    return res;
}

void precalculation()
{
    ff[0] = ff[1] = 1;
    for(ll i=2;i<length;i++)
    {
        ff[i] = (ff[i-1]*i) %mod;
    }
}

ll NCR(ll n, ll r)
{
    if(n<=0 || n<r)return 0;
    ll x = (ff[n]*inverse(ff[n-r]))%mod;
    x = (x*inverse(ff[r]))%mod;
    return x;
}

void solve()
{
    ll n, k; cin >> n >> k;
    if(k>n){
        cout << 0 << '\n';
        return;
    }
    if(k==1){
        cout << n << '\n';
        return;
    }
    precalculation();
    ll res = 0;
    for(ll i=1;i<=n;i++)
    {
        ll z = n/i; z--;
        res += NCR(z, k-1);
        res %= mod;
    }
    cout << res << '\n';
    return;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0);

    int test;

    test = 1;

    while(test--)
        solve();

    return 0;
}

//Coded by Abhijay Mitra
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <numeric>
#include <vector>
#include <iterator>
#include <map>
#include <set>
#include <climits>
#include <queue>
#include <iomanip>
#include <cmath>
#include <stack>
#include <cctype>
#include <bitset>
// #include <bits/stdc++.h>
#define double long double
#define int long long int
#define ll int
#define ibs ios_base::sync_with_stdio(false)
#define cti cin.tie(0)
#define bp __builtin_popcount
#define pb push_back
#define res(vector) v.resize(unique(v.begin(), v.end()) - v.begin());
#define timer cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
using namespace std;
const int N=2e6+10;
const int inf = /*0x3f3f3f3f*/1e9+10;
const ll M = 998244353 ; // Mulo
// const int M = 1e9+7 ; // Mulo
const double Pi = 3.14159265;
#define F first
#define S second
int n,k,ans;
ll powM(ll b, int p) {
  ll r=1;
  for(; p; b=b*b%M, p/=2)
    if(p&1)
      r=r*b%M;
  return r;
}
long long C(long long n,long long r)
{
    long long N=1,R=1;
    if(r>n or r<0)return 0;
    if(n==r or r==0)return 1;
    for(long long i=1;i<=n;i++) N=N*i%M;
    for(long long i=1;i<=r;i++) R=R*i%M;
    for(long long i=1;i<=n-r;i++) R=R*i%M;
    return (N*powM(R,M-2))%M;
}
int add(int a,int b){
  return ((a%M)+(b%M))%M;
}
void solve(){
  cin>>n>>k;
  for(int i=1;i<=n;i++){
    ans=add(ans,(C((n/i)-1,k-1)));
  }
  cout<<ans;
}
int32_t main()
{
  ibs;cti;
  solve()
  /*,cout<<"\n"*/;
  // cout<<"\n";
  int xx=0;
  // int t;cin>>t;while(t--){/*xx++;cout<<"Case "<<xx<<":\n"*/;solve();/*cout<<"\n";*/}
  return 0;
}

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <map>
using namespace std;
typedef long long ll;
const ll p = 998244353;
ll const MAXN = 1e6+5;
ll fct[MAXN];
ll rfct[MAXN];
ll modpow(ll a, ll b){
    if(b==0) return 1;
    ll c = modpow(a, b/2);
    c = (c * c) % p;
    if(b%2) c = c * a;
    return c % p;
}
void full(){
    fct[0] = 1;
    for(int i=1; i < MAXN; i ++){
        fct[i] = (i * fct[i-1]) % p;
        if(i < 10){
//            cout << fct[i] << ' ' << i << endl;
        }

    }
    rfct[MAXN-1] = modpow(fct[MAXN-1], p-2);
    for(int i=MAXN-2; i >= 0; i --){
        rfct[i] = (rfct[i+1] * (i+1)) % p;
    }
    return ;
}
ll cnk(ll a ,ll b){
    return (((fct[a] * rfct[b])%p) * rfct[a-b])% p;
}
ll lg(ll n , ll x){
    if(n < x) return 0;
    return lg(n/x , x) + 1;
}
int main() {
    ll n , k;
    cin >> n >> k;
    ll s = 0;
    full();
    if(k == 1){
        cout << n;
        return 0;
    }
    if(n < k) {
        cout << 0;
        return 0;
    }
    s = cnk(n-1 , k-1);
    //cout << s << endl;
    for(ll i = 2; i <= n; i ++){
        ll r = n / i;
       // cout <<i << ' ' <<  r << endl;
        if(r >= k){
            s = (s + cnk(r-1 , k-1)) % p;
        }
    }
    cout << s << endl;

}

#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>

#include<algorithm>
#include<cmath>
#include<map>
#include<vector>
#include<string>
#include<fstream>
#include<set>
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define forl(i,a,n) for(int i=a;i<n;i++)
#define rfor(i,n,a) for(int i=n;i>=a;i--)
#define ll long long
#define ld long double
#define pb push_back
#define ld long double
#define vi vector<int>
#define vll vector<long long>
#define pi pair<int,int>
#define pll pair<long long,long long>
#define mp make_pair
#define B begin()
#define E end()
#define S size()
#define m9 1000000007
using namespace std;

/*
string fs(string str1, string str2)
{    if (str1.length() > str2.length())
        swap(str1, str2);
      string str = "";
    int n1 = str1.length(), n2 = str2.length();
    int diff = n2 - n1;
      int carry = 0;
      for (int i=n1-1; i>=0; i--)
    {

        int sum = ((str1[i]-'0') +
                   (str2[i+diff]-'0') +
                   carry);
        str.push_back(sum%10 + '0');
        carry = sum/10;
    }
      for (int i=n2-n1-1; i>=0; i--)
    {
        int sum = ((str2[i]-'0')+carry);
        str.push_back(sum%10 + '0');
        carry = sum/10;
    }
      if (carry)
        str.push_back(carry+'0');
      reverse(str.begin(), str.end());

    return str;
}*/

ll gcd(ll x,ll y)
{
    if(x==0) return y;
    return gcd(y%x,x);
}

/*
ll gcdextended(ll a, ll b, ll *x, ll *y)
{
    if (a == 0)
    {
        *x = 0, *y = 1;
        return b;
    }

    ll x1, y1;
    int gcd = gcdextended(b%a, a, &x1, &y1);

    *x = y1 - (b/a) * x1;
    *y = x1;

    return gcd;
}

///RELATIVE COPRIME
ll modinverse(ll a, ll m)
{
    ll x, y;
   ll g = gcdextended(a, m, &x, &y);
    if (g != 1)
return -1;
    else
    {
        ll res = (x%m + m) % m;
        return res;
    }
}
  */
ll powmod(ll x, ll y, ll m)
{
    if (y == 0)
        return 1;
    ll p = powmod(x, y/2, m) % m;
    p = (p * p) % m;
    return (y%2 == 0)? p : (x * p) % m;
}
///M IS PRIME
ll modif(ll x,ll m){
return(powmod(x,m-2,m));

}

bool fa(vll &x,vll &y){return x[0]<y[0];}
bool fa1(vll &x,vll &y){return x[1]<y[1];}
bool f1(pll &x,pll &y){return x.second<y.second;}
bool f2(pll &x,pll &y){return x.first>y.first;}
bool f3(ll &x,ll &y){
    return x>y;
    }

#define p0(a) cout << a << " "
#define p1(a) cout << a << endl
#define p2(a, b) cout << a << " " << b << endl
#define p3(a, b, c) cout << a << " " << b << " " << c << endl
#define p4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define pin(a) for(auto x:a)cout<<x<<" ";cout<<endl
#define fck(a) cout<<a;exit(0)
#define vvll vector<vector<ll> >
#define A(b) b.begin(),b.end()

//cmd+return add new line in between
//cmd+2 beginning of line
//cmd+e end of line
//

//include<bits/stdc++.h>

int main()
{ fastio;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ll n,k;cin>>n>>k;

ll mo=998244353;
if(n<k){cout<<0;exit(0);}
ll b[n+1];
forl(i,0,n+1)b[i]=0;
k--;
b[k]=1;
//cout<<12777711870%mo<<endl;
//cout<<2505433700%mo<<endl;

for(ll i=k+1;i<=n;i++){
    ll x=i-k;
    b[i]=b[i-1]*i;
    ll y=modif(x,mo);
    y%=mo;
    b[i]%=mo;
    //cout<<y<<" "<<" "<<b[i]<<"\n";
    b[i]*=y;
    b[i]%=mo;
    //p3(i,x,b[i]);
}
//forl(i,0,n+1){p2(i,b[i]);}
ll ans=0;

forl(i,1,n+1){
    ll x=n/i;x--;
    if(x<0)continue;
    ans+=b[x];
    //cout<<b[x]<<endl;
    ans%=mo;
}
//cout<<endl;
cout<<ans%mo;

return 0;
}

//RITIK RAI
//#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;

#define int  long long int
#define uint unsigned long long int
#define ld long double
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define preci(x, y) fixed << setprecision(y) << x

#define vint vector<int>
#define sz(a) (int)a.size()
#define pb push_back
#define vmin *min_element
#define vmax *max_element
#define max_pq priority_queue<ll, vector<ll>>
#define min_pq priority_queue<ll, vector<ll>, greater<ll>>
#define mint map<int,int>
#define pint pair<int,int>
#define mp make_pair
#define F first
#define S second

#define all(x) x.begin(),x.end()
#define ub upper_bound
#define lb lower_bound
#define bin binary_search
#define revsort(v) sort(all(v), greater<ll>())

#define f(i,a,b) for(int i=a;i<b;i++)
#define rf(i,a,b) for(int i=a;i>b;i--)

#define fbo find_by_order
#define ook order_of_key
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> Set;

void ritikio();

#define PI 3.1415926535897932384626 // atan(1.0)*4.0;
const int inff = LLONG_MAX;
const int minff = LLONG_MIN;
const int inf = 1e12;
const int pmod = 998244353;
const int mod = 1e9 + 7;
const int maxm = 2e6 + 3;
const int maxN = 1e5 + 3;

int fac[maxm + 1];

/* Iterative Function to calculate (x^y)%p
in O(log y) */
int power(int x, int y, int p)
{
    int res = 1; // Initialize result

    x = x % p; // Update x if it is more than or
    // equal to p

    while (y > 0) {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res * x) % p;

        // y must be even now
        y = y >> 1; // y = y/2
        x = (x * x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
int modInverse(int n, int p)
{
    return power(n, p - 2, p);
}

// Returns nCr % p using Fermat's little
// theorem.
int nCrModPFermat(int n, int r, int p)
{
    // Base case
    if (r == 0)
        return 1;

    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r

    return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
}

void solve()
{
    int n,k; cin>>n>>k;
    int ans=0;
    int i=1;
    while(1)
    {
        int r=n/i-1; i++;
        if(r<(k-1)) break;
        ans=(ans+nCrModPFermat(r,k-1,pmod))%pmod;
    }
    cout<<ans<<endl;
}

signed main()
{
    ritikio();
    int T = 1;
    //cin>>T;

    fac[0] = 1;
    for (int i = 1; i <= maxm; i++)
        fac[i] = (fac[i - 1] * i) % pmod;

    while(T--)
    {
        solve();
    }
}

void ritikio()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("input999.txt", "r", stdin);
    freopen("output999.txt", "w", stdout);
#endif
}

#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>

#define INF 1000000021
#define pb push_back
#define sqr(a) (a)*(a)
#define M(a, b) make_pair(a,b)
#define T(a, b, c) make_pair(a, make_pair(b, c))
#define F first
#define S second
#define all(x) (x.begin(), x.end())
#define deb(x) cerr << #x << " = " << x << '\n'
#define N 222222

using namespace std;
//using namespace __gnu_pbds;

typedef long double ld;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

const ld pi = 2 * acos(0.0);
template<class T> bool umin(T& a, T b){if(a>b){a=b;return 1;}return 0;}
template<class T> bool umax(T& a, T b){if(a<b){a=b;return 1;}return 0;}
template<class T, class TT> bool pal(T a, TT n){int k=0;for(int i=0;i<=n/2;i++){if(a[i]!=a[n-i-1]){k=1;break;}}return k?0:1;}

//int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
const ll MOD = 998244353ll;
ll bn(ll a, ll n)
{
	ll r = 1;
	for(;n > 0; n >>= 1ll)
	{
		if(n & 1)
			r = (r * a) % MOD;
		a = (a * a) % MOD;
	}
	return r;
}
ll f[N*4];
ll cnk(ll n, ll k)
{
	if(n == k)
		return 1;
	if(n < k)
		return 0;
	ll q = f[n];
	ll p = (f[n-k]*f[k]) % MOD;
	ll o = (q*bn(p, MOD - 2)) % MOD;
	return o;
}

int main()
{
	f[0] = 1;
	for(ll i = 1; i <= N*3; i ++)
	{
		f[i] = (f[i - 1] * i) %MOD;
	}
	ll n, k;
	cin >> n >> k;
	if(k == 1)
	return cout << n,0;
	ll ans = 0;
	for(int i = 1; i <= n; i ++)
	{
		ll q = n/i-1;
		ans = (ans + cnk(q, k - 1)) % MOD;
	}
	cout << ans << '\n';

	getchar();
	getchar();
	return 0;
	//ios::sync_with_stdio(false);
	//cin.tie(0);
}

#include <bits/stdc++.h>
using namespace std;
long long fac[500001],inv[500001];
const int mod=998244353;
long long ksm(long long a,long long b)
{
	long long t=1ll;
	while(b)
	{
		if(b&1) t=(t*a)%mod;
		b>>=1;
		a=(a*a)%mod;
	}
	return t;
}
long long C(int n,int m)
{
	return fac[n]*inv[m]%mod*inv[n-m]%mod;
}
int main()
{
	int n,k;
	scanf("%d%d",&n,&k);
	fac[0]=1;
	for(int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%mod;
	inv[n]=ksm(fac[n],mod-2);
	for(int i=n-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		int tmp=n/i-1;
		if(1+tmp>=k)
		ans=(ans+C(tmp,k-1))%mod;
	}
	printf("%d\n",ans);
	return 0;
}

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ls rt<<1
#define rs rt<<1|1
#define fi first
#define se second
#define pb push_back
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const  ll inf  = 0x3f3f3f3f3f3f3f3f;
const int mod  = 998244353;
const int maxn = 5e5 + 6;
const int N    = 1e3+5;
const double eps = 1e-6;
ll qpow(ll x,ll y){ll ans=1;x%=mod;while(y){ if(y&1) ans=ans*x%mod; x=x*x%mod; y>>=1;}return ans;}

ll n,k,fac[maxn],inv[maxn],ans;
ll C(int x,int y) {
    if(y>x) return 0;
    return fac[x]*inv[x-y]%mod*inv[y]%mod;
}
int main(){
    //freopen("input.in","r",stdin);
    fac[0]=inv[0]=1;
    for(int i=1;i<=5e5;i++) fac[i]=fac[i-1]*i%mod;
    for(int i=1;i<=5e5;i++) inv[i]=qpow(fac[i],mod-2);
    //n=5e5,k=1;
    scanf("%lld%lld",&n,&k);
    for(int i=1;i<=n-k+1;i++) {
        ll cnt=0;
        //for(int j=i+i;j<=n;j+=i) cnt++;
        cnt = n/i-1;
        ans=(ans+C(cnt,k-1))%mod;
        //cout<<cnt<<','<<k<<endl;
    }
    printf("%lld\n",ans);
//    for(scanf("%d",&_);_;_--) {
//
//    }
}

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ls rt<<1
#define rs rt<<1|1
#define fi first
#define se second
#define pb push_back
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const  ll inf  = 0x3f3f3f3f3f3f3f3f;
const int mod  = 998244353;
const int maxn = 5e5 + 6;
const int N    = 1e3+5;
const double eps = 1e-6;
ll qpow(ll x,ll y){ll ans=1;x%=mod;while(y){ if(y&1) ans=ans*x%mod; x=x*x%mod; y>>=1;}return ans;}

ll n,k,fac[maxn],inv[maxn],ans;
ll C(int x,int y) {
    if(y>x) return 0;
    return fac[x]*inv[x-y]%mod*inv[y]%mod;
}
int main(){
    //freopen("input.in","r",stdin);
    fac[0]=inv[0]=1;
    for(int i=1;i<=5e5;i++) fac[i]=fac[i-1]*i%mod;
    for(int i=1;i<=5e5;i++) inv[i]=qpow(fac[i],mod-2);
    scanf("%lld%lld",&n,&k);
    for(int i=1;i<=n-k+1;i++) {
        ll cnt=0;
        for(int j=i+i;j<=n;j+=i) cnt++;
        ans=(ans+C(cnt,k-1))%mod;
        //cout<<cnt<<','<<k<<endl;
    }
    printf("%lld\n",ans);
//    for(scanf("%d",&_);_;_--) {
//
//    }
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#define ll long long
using namespace std;
const int maxn=2e5+7;
const int inf=0x3f3f3f3f;
const int mod=998244353;
ll n,k;
ll ans;
ll pre[500005];
ll kpow(ll x,ll y)
{
    ll z=1;
    while(y)
    {
        if(y&1)z=(z*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return z;
}
ll C(ll x,ll y)
{
    return (pre[x]*kpow((pre[y]*pre[x-y])%mod,mod-2))%mod;
}
int main()
{
    cin>>n>>k;
    pre[0]=1;
    for(int i=1;i<=n;i++)
    {
        pre[i]=(pre[i-1]*i)%mod;
    }
    ans=0;
    for(int i=1;i<=n;i++)
    {
        ll cnt=n/i;
        if(cnt<k)break;
        ans=(ans+C(cnt-1,k-1))%mod;
    }
    cout<<ans<<endl;
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define X first
#define Y second

/* <not-serious> */
template<typename T>
struct number_iterator :
            iterator<forward_iterator_tag, T> {
    T v, step;
    number_iterator(T _v) : v(_v), step(1) {}
    number_iterator(T _v, T _step) : v(_v), step(_step) {}
    operator T &() { return v; }
    T operator*() const { return v; }
    number_iterator operator++() {
        v += step;
        return *this;
    }
    bool operator!=(number_iterator rhs) {
        return step > 0 ? v < rhs.v : v > rhs.v;
    }
};

template<typename T = int>
struct range : pair<T, T> {
    T step;
    T _end(T begin, T end, T _step) {
        return _step > 0 ? max(begin, end) :
                           min(begin, end - 1);
    }
    using ptt = pair<T, T>;
    range(T begin, T end) : ptt(begin, max(begin, end)),
                            step(1) {}
    range(T end) : ptt(0, max<T>(0, end)), step(1) {}
    range(T begin, T end, T _step) :
            ptt(begin, _end(begin, end, _step)),
            step(_step) {}
    number_iterator<T> begin() const {
        return number_iterator<T>(this->first, step);
    }
    number_iterator<T> end() const {
        return number_iterator<T>(this->second, step);
    }
};

template<typename T = int>
struct rrange : range<T> {
    rrange(T end, T begin) : range<T>(end, begin, -1) {}
    rrange(T end) : range<T>(end, 0, -1) {}
};

#if __cplusplus >= 201703L
template<class T = int, class... Args>
auto vec(size_t n, Args &&... args) {
    if constexpr(sizeof...(args) == 1)
        return vector<T>(n, T(args...));
    else
        return vector(n, vec<T>(args...));
}
#else
template<int D, typename T>
struct vec : public vector<vec<D - 1, T>> {
    template<typename... Args>
    vec(int n = 0, Args... args) :
    vector<vec<D - 1, T>>(n, vec <D - 1, T>(args...)) {}
};

template<typename T>
struct vec<1, T> : public vector<T> {
    vec(int n = 0, const T &val = T()) :
    vector<T>(n, val) {}
};
#endif

template<typename T>
inline int constexpr size(T &cont) {
    return cont.size();
}
/* </not-serious> */

template<typename T>
struct Modular {
    int val;
    static int constexpr mod() { return T::value; };

    Modular(long long v = 0) {
        val = v % mod();
        if (val < 0) val += mod();
    }

    Modular(long long a, long long b) : val(0) {
        *this += a;
        *this /= b;
    }

    Modular &operator+=(Modular const &b) {
        val += b.val;
        if (val >= mod()) val -= mod();
        return *this;
    }

    Modular &operator-=(Modular const &b) {
        val -= b.val;
        if (val < 0) val += mod();
        return *this;
    }

    Modular &operator*=(Modular const &b) {
        val = (long long) val * b.val % mod();
        return *this;
    }

    friend Modular mexp(Modular a, long long e) {
        Modular res = 1;
        while (e) {
            if (e & 1) res *= a;
            a *= a;
            e >>= 1;
        }
        return res;
    }

    friend Modular inverse(Modular a) {
        return mexp(a, mod() - 2);
    }

    Modular &operator/=(Modular const &b) {
        return *this *= inverse(b);
    }

    friend Modular
    operator+(Modular a, Modular const b) { return a += b; }

    friend Modular
    operator-(Modular a, Modular const b) { return a -= b; }

    friend Modular operator-(Modular const a) {
        return 0 - a;
    }

    friend Modular
    operator*(Modular a, Modular const b) { return a *= b; }

    friend Modular
    operator/(Modular a, Modular const b) { return a /= b; }

    friend Modular operator%(Modular a, Modular const b) {
        return a.val %= b.val;
    }

    friend std::ostream &
    operator<<(std::ostream &os, Modular const &a) {
        return os << a.val;
    }

#define IMPLEMENT_COMPARE_OPERATOR(x) \
    friend bool operator x (Modular const& a, Modular const& b) { \
            return a.val x b.val; \
    }

    IMPLEMENT_COMPARE_OPERATOR(<)

    IMPLEMENT_COMPARE_OPERATOR(>)

    IMPLEMENT_COMPARE_OPERATOR(<=)

    IMPLEMENT_COMPARE_OPERATOR(>=)

    IMPLEMENT_COMPARE_OPERATOR(==)

    IMPLEMENT_COMPARE_OPERATOR(!=)
};

//struct VarMod { static int value; };
//int VarMod::value;
//int& MOD = VarMod::value;
//using Mint = Modular<VarMod>;

int constexpr MOD = 998244353;
using Mint = Modular<std::integral_constant<int, MOD>>;

vector<Mint> fact;
vector<Mint> invfact;

inline void ffact(int n) {
    static int _prev = -1;
    if (n <= _prev) return;
    fact.resize(n + 1, 1);
    for (int i = max(1, _prev + 1); i <= n; i++) fact[i] = fact[i - 1] * i;
    _prev = n;
}

inline void finv(int n) {
    static int _prev = -1;
    if (n <= _prev) return;
    ffact(n);
    invfact.resize(n + 1, inverse(Mint(fact[n])));
    for (int i = n; i >= max(1, _prev + 1); i--) invfact[i - 1] = invfact[i] * i;
    _prev = n;
}

inline void fcomb(int n) {
    static int _prev = -1;
    if (n <= _prev) return;
    ffact(n);
    finv(n);
    _prev = n;
}

inline Mint nCrmod(int n, int r) {
    if (r > n || r < 0) return 0;
    fcomb(n);
    return fact[n] * invfact[r] * invfact[n - r];
}

// real nCr;
using CombInt = Mint;
vector<vector<CombInt>> nCr; // use with bound checking

inline void fnCr(int n) {
    nCr.assign(n + 1, vector<CombInt>(n + 1, 0));
    nCr[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= i; j++) {
            nCr[i][j] = nCr[i - 1][j] + (j ? nCr[i - 1][j - 1] : 0);
        }
    }
}

ll constexpr INF = 1e18;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, k;
    cin >> n >> k;
    if (k > n) {
        cout << 0;
        return 0;
    }
    Mint ans = 0;
    for (auto i : range(1, n + 1)) {
        int last = n - n % i;
        int cnt = (last - 2 * i) / i + 1;
        if (k - 1 > cnt) continue;
        ans += nCrmod(cnt, k - 1);
    }
    cout << ans;
    return 0;
}

// Author: Tyler Wang

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

using namespace std;

template <class C>
constexpr auto ssize(const C& c)
    -> std::common_type_t<std::ptrdiff_t,
                          std::make_signed_t<decltype(c.size())>> {
  return (std::common_type_t<std::ptrdiff_t,
                             std::make_signed_t<decltype(c.size())>>)c.size();
}

template <class T, std::ptrdiff_t N>
constexpr std::ptrdiff_t ssize(const T (&)[N]) noexcept {
  return N;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, bool> has_single_bit(
    T x) noexcept {
  return x != 0 && (x & (x - 1)) == 0;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countl_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_clz(x) - (std::numeric_limits<unsigned>::digits -
                               std::numeric_limits<T>::digits);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_clzl(x) - (std::numeric_limits<unsigned long>::digits -
                                std::numeric_limits<T>::digits);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_clzll(x) -
           (std::numeric_limits<unsigned long long>::digits -
            std::numeric_limits<T>::digits);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countr_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_ctz(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_ctzl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_ctzll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> popcount(T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_popcount(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long long)) {
    return __builtin_popcountl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_popcountll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_width(T x) noexcept {
  return (T)(std::numeric_limits<T>::digits - countl_zero(x));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_ceil(T x) noexcept {
  return (T)(x <= 1 ? 1 : (T)1 << bit_width((T)(x - 1)));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_floor(T x) noexcept {
  return (T)(x == 0 ? 0 : (T)1 << (bit_width(x) - 1));
}

template <class Fun>
class y_combinator_result {
 public:
  template <class T>
  explicit y_combinator_result(T&& fun) : fun_(std::forward<T>(fun)) {}

  template <class... Args>
  decltype(auto) operator()(Args&&... args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }

 private:
  Fun fun_;
};

template <class Fun>
decltype(auto) y_combinator(Fun&& fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::optional<T>& opt) {
  return opt ? os << *opt : os << "nullopt";
}

template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <typename Container,
          std::enable_if_t<!std::is_convertible_v<Container, std::string_view>,
                           typename Container::const_iterator>* = nullptr>
std::ostream& operator<<(std::ostream& os, const Container& c) {
  os << '{';
  for (auto it = c.begin(); it != c.end(); ++it) {
    if (it != c.begin()) {
      os << ", ";
    }
    os << *it;
  }
  return os << '}';
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::stack<T, Container> s) {
  std::vector<T> v(s.size());
  for (auto it = v.rbegin(); it != v.rend(); ++it) {
    *it = s.top();
    s.pop();
  }
  return os << v;
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::queue<T, Container> q) {
  os << '{';
  if (!q.empty()) {
    os << q.front();
    q.pop();
    while (!q.empty()) {
      os << ", " << q.front();
      q.pop();
    }
  }
  return os << '}';
}

template <typename T, typename Container, typename Compare>
std::ostream& operator<<(std::ostream& os,
                         std::priority_queue<T, Container, Compare> pq) {
  os << '{';
  if (!pq.empty()) {
    os << pq.top();
    pq.pop();
    while (!pq.empty()) {
      os << ", " << pq.top();
      pq.pop();
    }
  }
  return os << '}';
}

namespace detail {

template <int I, typename... Ts>
void tuple_print(std::ostream& os, const std::tuple<Ts...>& t) {
  static_assert(0 <= I && I <= sizeof...(Ts));
  if constexpr (I != sizeof...(Ts)) {
    if constexpr (I != 0) {
      os << ", ";
    }
    os << std::get<I>(t);
    tuple_print<I + 1>(os, t);
  }
}

}  // namespace detail

template <typename... Ts>
std::ostream& operator<<(std::ostream& os, const std::tuple<Ts...>& t) {
  os << '{';
  detail::tuple_print<0>(os, t);
  return os << '}';
}

namespace detail {

template <typename T1, typename... Ts>
void debug_print(std::string_view keys, const T1& val1, const Ts&... vals) {
  if constexpr (sizeof...(Ts) == 0) {
    std::cerr << keys << " = " << val1 << std::endl;
  } else {
    for (int i = 0, paren = 0; i < (int)keys.size(); ++i) {
      if (keys[i] == '(' || keys[i] == '{') {
        ++paren;
      } else if (keys[i] == ')' || keys[i] == '}') {
        --paren;
      } else if (keys[i] == ',' && paren == 0) {
        std::cerr << keys.substr(0, i) << " = " << val1 << ',';
        return debug_print(keys.substr(i + 1), vals...);
      }
    }
  }
}

template <typename... Ts>
void debug_print(int line, const Ts&... keyvals) {
  if constexpr (sizeof...(Ts) <= 1) {
    std::cerr << "  " << line << " |" << std::endl;
  } else {
    std::cerr << "  " << line << " | ";
    debug_print(keyvals...);
  }
}

}  // namespace detail

#if defined(TYLER) && defined(__GNUC__) && __GNUC__ >= 8
#define debug(...) \
  detail::debug_print(__LINE__, #__VA_ARGS__ __VA_OPT__(, ) __VA_ARGS__)
#elif defined(TYLER)
#define debug(...) detail::debug_print(__LINE__, #__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) ((void)0)
#endif

constexpr int MODULUS = 998244353;

template <const int& Modulus = MODULUS>
class mod_int {
 public:
  constexpr mod_int() : val_(0) {}

  template <typename T>
  constexpr mod_int(T val) : val_((int)(val % Modulus)) {
    static_assert(std::is_integral_v<T>);
    if (val_ < 0) {
      val_ += Modulus;
    }
  }

  static constexpr int modulus() { return Modulus; }

  template <typename T>
  constexpr explicit operator T() const {
    return (T)val_;
  }

  constexpr mod_int& operator++() {
    if (++val_ == Modulus) {
      val_ = 0;
    }
    return *this;
  }

  constexpr mod_int operator++(int) {
    mod_int t = *this;
    ++*this;
    return t;
  }

  constexpr mod_int& operator--() {
    if (val_ == 0) {
      val_ = Modulus;
    }
    --val_;
    return *this;
  }

  constexpr mod_int operator--(int) {
    mod_int t = *this;
    --*this;
    return t;
  }

  constexpr mod_int operator+=(mod_int other) {
    if ((val_ += other.val_) >= Modulus) {
      val_ -= Modulus;
    }
    return *this;
  }

  constexpr mod_int operator-=(mod_int other) {
    if ((val_ -= other.val_) < 0) {
      val_ += Modulus;
    }
    return *this;
  }

  constexpr mod_int operator*=(mod_int other) {
    val_ = (int)((long long)val_ * other.val_ % Modulus);
    return *this;
  }

  constexpr mod_int operator/=(mod_int other) { return *this *= inv(other); }

  friend constexpr mod_int operator+(mod_int mi) { return mi; }

  friend constexpr mod_int operator-(mod_int mi) {
    if (mi.val_ != 0) {
      mi.val_ = Modulus - mi.val_;
    }
    return mi;
  }

  friend constexpr mod_int operator+(mod_int lhs, mod_int rhs) {
    return lhs += rhs;
  }

  friend constexpr mod_int operator-(mod_int lhs, mod_int rhs) {
    return lhs -= rhs;
  }

  friend constexpr mod_int operator*(mod_int lhs, mod_int rhs) {
    return lhs *= rhs;
  }

  friend constexpr mod_int operator/(mod_int lhs, mod_int rhs) {
    return lhs /= rhs;
  }

  friend constexpr bool operator==(mod_int lhs, mod_int rhs) {
    return lhs.val_ == rhs.val_;
  }

  friend constexpr bool operator!=(mod_int lhs, mod_int rhs) {
    return lhs.val_ != rhs.val_;
  }

  friend constexpr bool operator<(mod_int lhs, mod_int rhs) {
    return lhs.val_ < rhs.val_;
  }

  friend constexpr bool operator<=(mod_int lhs, mod_int rhs) {
    return lhs.val_ <= rhs.val_;
  }

  friend constexpr bool operator>(mod_int lhs, mod_int rhs) {
    return lhs.val_ > rhs.val_;
  }

  friend constexpr bool operator>=(mod_int lhs, mod_int rhs) {
    return lhs.val_ >= rhs.val_;
  }

  friend std::ostream& operator<<(std::ostream& os, mod_int mi) {
    return os << mi.val_;
  }

  friend std::istream& operator>>(std::istream& is, mod_int& mi) {
    long long val;
    is >> val;
    mi = mod_int(val);
    return is;
  }

  friend constexpr mod_int inv(mod_int mi) {
    int a = mi.val_, b = Modulus;
    int x = 0, xx = 1;
    while (a != 0) {
      int q = b / a;
      int t = a;
      a = b - q * a;
      b = t;
      t = xx;
      xx = x - q * xx;
      x = t;
    }
    return mod_int(x);
  }

  template <typename T>
  friend constexpr mod_int pow(mod_int base, T expo) {
    static_assert(std::is_integral_v<T>);
    if (expo < 0) {
      base = inv(base);
      expo = -expo;
    }
    mod_int power = 1;
    for (; expo != 0; expo >>= 1) {
      if (expo & 1) {
        power *= base;
      }
      base *= base;
    }
    return power;
  }

 private:
  int val_;
};

// Modular combinatorics.
template <const int& Modulus = MODULUS>
class mod_comb {
 public:
  mod_comb(int n) : fact_(n + 1), inv_fact_(n + 1) {
    fact_[0] = 1;
    for (int i = 1; i <= n; ++i) {
      fact_[i] = fact_[i - 1] * i;
    }
    inv_fact_[n] = inv(fact_[n]);
    for (int i = n; i >= 1; --i) {
      inv_fact_[i - 1] = inv_fact_[i] * i;
    }
  }

  mod_int<Modulus> factorial(int n) const { return fact_[n]; }

  mod_int<Modulus> permute(int n, int k) const {
    return fact_[n] * inv_fact_[n - k];
  }

  mod_int<Modulus> choose(int n, int k) const {
    return fact_[n] * inv_fact_[n - k] * inv_fact_[k];
  }

 private:
  std::vector<mod_int<Modulus>> fact_, inv_fact_;
};

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  std::cerr.precision(12);
  std::mt19937 rng((std::uint_fast32_t)std::chrono::high_resolution_clock::now()
                       .time_since_epoch()
                       .count());
  int n, k;
  cin >> n >> k;
  mod_comb comb(n);
  mod_int ans;
  for (int i = 1; n / i >= k; ++i) {
    ans += comb.choose(n / i - 1, k - 1);
  }
  cout << ans << '\n';
  return 0;
}

// Author: Tyler Wang

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

using namespace std;

template <class C>
constexpr auto ssize(const C& c)
    -> std::common_type_t<std::ptrdiff_t,
                          std::make_signed_t<decltype(c.size())>> {
  return (std::common_type_t<std::ptrdiff_t,
                             std::make_signed_t<decltype(c.size())>>)c.size();
}

template <class T, std::ptrdiff_t N>
constexpr std::ptrdiff_t ssize(const T (&)[N]) noexcept {
  return N;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, bool> has_single_bit(
    T x) noexcept {
  return x != 0 && (x & (x - 1)) == 0;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countl_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_clz(x) - (std::numeric_limits<unsigned>::digits -
                               std::numeric_limits<T>::digits);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_clzl(x) - (std::numeric_limits<unsigned long>::digits -
                                std::numeric_limits<T>::digits);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_clzll(x) -
           (std::numeric_limits<unsigned long long>::digits -
            std::numeric_limits<T>::digits);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countr_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_ctz(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_ctzl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_ctzll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> popcount(T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_popcount(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long long)) {
    return __builtin_popcountl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_popcountll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_width(T x) noexcept {
  return (T)(std::numeric_limits<T>::digits - countl_zero(x));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_ceil(T x) noexcept {
  return (T)(x <= 1 ? 1 : (T)1 << bit_width((T)(x - 1)));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_floor(T x) noexcept {
  return (T)(x == 0 ? 0 : (T)1 << (bit_width(x) - 1));
}

template <class Fun>
class y_combinator_result {
 public:
  template <class T>
  explicit y_combinator_result(T&& fun) : fun_(std::forward<T>(fun)) {}

  template <class... Args>
  decltype(auto) operator()(Args&&... args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }

 private:
  Fun fun_;
};

template <class Fun>
decltype(auto) y_combinator(Fun&& fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::optional<T>& opt) {
  return opt ? os << *opt : os << "nullopt";
}

template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <typename Container,
          std::enable_if_t<!std::is_convertible_v<Container, std::string_view>,
                           typename Container::const_iterator>* = nullptr>
std::ostream& operator<<(std::ostream& os, const Container& c) {
  os << '{';
  for (auto it = c.begin(); it != c.end(); ++it) {
    if (it != c.begin()) {
      os << ", ";
    }
    os << *it;
  }
  return os << '}';
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::stack<T, Container> s) {
  std::vector<T> v(s.size());
  for (auto it = v.rbegin(); it != v.rend(); ++it) {
    *it = s.top();
    s.pop();
  }
  return os << v;
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::queue<T, Container> q) {
  os << '{';
  if (!q.empty()) {
    os << q.front();
    q.pop();
    while (!q.empty()) {
      os << ", " << q.front();
      q.pop();
    }
  }
  return os << '}';
}

template <typename T, typename Container, typename Compare>
std::ostream& operator<<(std::ostream& os,
                         std::priority_queue<T, Container, Compare> pq) {
  os << '{';
  if (!pq.empty()) {
    os << pq.top();
    pq.pop();
    while (!pq.empty()) {
      os << ", " << pq.top();
      pq.pop();
    }
  }
  return os << '}';
}

namespace detail {

template <int I, typename... Ts>
void tuple_print(std::ostream& os, const std::tuple<Ts...>& t) {
  static_assert(0 <= I && I <= sizeof...(Ts));
  if constexpr (I != sizeof...(Ts)) {
    if constexpr (I != 0) {
      os << ", ";
    }
    os << std::get<I>(t);
    tuple_print<I + 1>(os, t);
  }
}

}  // namespace detail

template <typename... Ts>
std::ostream& operator<<(std::ostream& os, const std::tuple<Ts...>& t) {
  os << '{';
  detail::tuple_print<0>(os, t);
  return os << '}';
}

namespace detail {

template <typename T1, typename... Ts>
void debug_print(std::string_view keys, const T1& val1, const Ts&... vals) {
  if constexpr (sizeof...(Ts) == 0) {
    std::cerr << keys << " = " << val1 << std::endl;
  } else {
    for (int i = 0, paren = 0; i < (int)keys.size(); ++i) {
      if (keys[i] == '(' || keys[i] == '{') {
        ++paren;
      } else if (keys[i] == ')' || keys[i] == '}') {
        --paren;
      } else if (keys[i] == ',' && paren == 0) {
        std::cerr << keys.substr(0, i) << " = " << val1 << ',';
        return debug_print(keys.substr(i + 1), vals...);
      }
    }
  }
}

template <typename... Ts>
void debug_print(int line, const Ts&... keyvals) {
  if constexpr (sizeof...(Ts) <= 1) {
    std::cerr << "  " << line << " |" << std::endl;
  } else {
    std::cerr << "  " << line << " | ";
    debug_print(keyvals...);
  }
}

}  // namespace detail

#if defined(TYLER) && defined(__GNUC__) && __GNUC__ >= 8
#define debug(...) \
  detail::debug_print(__LINE__, #__VA_ARGS__ __VA_OPT__(, ) __VA_ARGS__)
#elif defined(TYLER)
#define debug(...) detail::debug_print(__LINE__, #__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) ((void)0)
#endif

constexpr int MODULUS = 998244353;

template <const int& Modulus = MODULUS>
class mod_int {
 public:
  constexpr mod_int() : val_(0) {}

  template <typename T>
  constexpr mod_int(T val) : val_((int)(val % Modulus)) {
    static_assert(std::is_integral_v<T>);
    if (val_ < 0) {
      val_ += Modulus;
    }
  }

  static constexpr int modulus() { return Modulus; }

  template <typename T>
  constexpr explicit operator T() const {
    return (T)val_;
  }

  constexpr mod_int& operator++() {
    if (++val_ == Modulus) {
      val_ = 0;
    }
    return *this;
  }

  constexpr mod_int operator++(int) {
    mod_int t = *this;
    ++*this;
    return t;
  }

  constexpr mod_int& operator--() {
    if (val_ == 0) {
      val_ = Modulus;
    }
    --val_;
    return *this;
  }

  constexpr mod_int operator--(int) {
    mod_int t = *this;
    --*this;
    return t;
  }

  constexpr mod_int operator+=(mod_int other) {
    if ((val_ += other.val_) >= Modulus) {
      val_ -= Modulus;
    }
    return *this;
  }

  constexpr mod_int operator-=(mod_int other) {
    if ((val_ -= other.val_) < 0) {
      val_ += Modulus;
    }
    return *this;
  }

  constexpr mod_int operator*=(mod_int other) {
    val_ = (int)((long long)val_ * other.val_ % Modulus);
    return *this;
  }

  constexpr mod_int operator/=(mod_int other) { return *this *= inv(other); }

  friend constexpr mod_int operator+(mod_int mi) { return mi; }

  friend constexpr mod_int operator-(mod_int mi) {
    if (mi.val_ != 0) {
      mi.val_ = Modulus - mi.val_;
    }
    return mi;
  }

  friend constexpr mod_int operator+(mod_int lhs, mod_int rhs) {
    return lhs += rhs;
  }

  friend constexpr mod_int operator-(mod_int lhs, mod_int rhs) {
    return lhs -= rhs;
  }

  friend constexpr mod_int operator*(mod_int lhs, mod_int rhs) {
    return lhs *= rhs;
  }

  friend constexpr mod_int operator/(mod_int lhs, mod_int rhs) {
    return lhs /= rhs;
  }

  friend constexpr bool operator==(mod_int lhs, mod_int rhs) {
    return lhs.val_ == rhs.val_;
  }

  friend constexpr bool operator!=(mod_int lhs, mod_int rhs) {
    return lhs.val_ != rhs.val_;
  }

  friend constexpr bool operator<(mod_int lhs, mod_int rhs) {
    return lhs.val_ < rhs.val_;
  }

  friend constexpr bool operator<=(mod_int lhs, mod_int rhs) {
    return lhs.val_ <= rhs.val_;
  }

  friend constexpr bool operator>(mod_int lhs, mod_int rhs) {
    return lhs.val_ > rhs.val_;
  }

  friend constexpr bool operator>=(mod_int lhs, mod_int rhs) {
    return lhs.val_ >= rhs.val_;
  }

  friend std::ostream& operator<<(std::ostream& os, mod_int mi) {
    return os << mi.val_;
  }

  friend std::istream& operator>>(std::istream& is, mod_int& mi) {
    long long val;
    is >> val;
    mi = mod_int(val);
    return is;
  }

  friend constexpr mod_int inv(mod_int mi) {
    int a = mi.val_, b = Modulus;
    int x = 0, xx = 1;
    while (a != 0) {
      int q = b / a;
      int t = a;
      a = b - q * a;
      b = t;
      t = xx;
      xx = x - q * xx;
      x = t;
    }
    return mod_int(x);
  }

  template <typename T>
  friend constexpr mod_int pow(mod_int base, T expo) {
    static_assert(std::is_integral_v<T>);
    if (expo < 0) {
      base = inv(base);
      expo = -expo;
    }
    mod_int power = 1;
    for (; expo != 0; expo >>= 1) {
      if (expo & 1) {
        power *= base;
      }
      base *= base;
    }
    return power;
  }

 private:
  int val_;
};

template <const int& Modulus = MODULUS>
class choose {
 public:
  choose(int n) : fact_(n + 1), inv_fact_(n + 1) {
    fact_[0] = 1;
    for (int i = 1; i <= n; ++i) {
      fact_[i] = fact_[i - 1] * i;
    }
    inv_fact_[n] = inv(fact_[n]);
    for (int i = n; i >= 1; --i) {
      inv_fact_[i - 1] = inv_fact_[i] * i;
    }
  }

  mod_int<Modulus> solve(int n, int k) const {
    return fact_[n] * inv_fact_[k] * inv_fact_[n - k];
  }

 private:
  std::vector<mod_int<Modulus>> fact_, inv_fact_;
};

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  std::cerr.precision(12);
  std::mt19937 rng((std::uint_fast32_t)std::chrono::high_resolution_clock::now()
                       .time_since_epoch()
                       .count());
  int n, k;
  cin >> n >> k;
  choose c(n);
  mod_int ans;
  for (int i = 1; n / i >= k; ++i) {
    ans += c.solve(n / i - 1, k - 1);
  }
  cout << ans << '\n';
  return 0;
}

// Author: Tyler Wang

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

using namespace std;

template <class C>
constexpr auto ssize(const C& c)
    -> std::common_type_t<std::ptrdiff_t,
                          std::make_signed_t<decltype(c.size())>> {
  return (std::common_type_t<std::ptrdiff_t,
                             std::make_signed_t<decltype(c.size())>>)c.size();
}

template <class T, std::ptrdiff_t N>
constexpr std::ptrdiff_t ssize(const T (&)[N]) noexcept {
  return N;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, bool> has_single_bit(
    T x) noexcept {
  return x != 0 && (x & (x - 1)) == 0;
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countl_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_clz(x) - (std::numeric_limits<unsigned>::digits -
                               std::numeric_limits<T>::digits);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_clzl(x) - (std::numeric_limits<unsigned long>::digits -
                                std::numeric_limits<T>::digits);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_clzll(x) -
           (std::numeric_limits<unsigned long long>::digits -
            std::numeric_limits<T>::digits);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> countr_zero(
    T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_ctz(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long)) {
    return __builtin_ctzl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_ctzll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, int> popcount(T x) noexcept {
  if constexpr (sizeof(T) <= sizeof(unsigned)) {
    return __builtin_popcount(x);
  } else if constexpr (sizeof(T) <= sizeof(unsigned long long)) {
    return __builtin_popcountl(x);
  } else {
    static_assert(sizeof(T) <= sizeof(unsigned long long));
    return __builtin_popcountll(x);
  }
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_width(T x) noexcept {
  return (T)(std::numeric_limits<T>::digits - countl_zero(x));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_ceil(T x) noexcept {
  return (T)(x <= 1 ? 1 : (T)1 << bit_width((T)(x - 1)));
}

template <typename T>
constexpr std::enable_if_t<std::is_unsigned_v<T>, T> bit_floor(T x) noexcept {
  return (T)(x == 0 ? 0 : (T)1 << (bit_width(x) - 1));
}

template <class Fun>
class y_combinator_result {
 public:
  template <class T>
  explicit y_combinator_result(T&& fun) : fun_(std::forward<T>(fun)) {}

  template <class... Args>
  decltype(auto) operator()(Args&&... args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }

 private:
  Fun fun_;
};

template <class Fun>
decltype(auto) y_combinator(Fun&& fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::optional<T>& opt) {
  return opt ? os << *opt : os << "nullopt";
}

template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <typename Container,
          std::enable_if_t<!std::is_convertible_v<Container, std::string_view>,
                           typename Container::const_iterator>* = nullptr>
std::ostream& operator<<(std::ostream& os, const Container& c) {
  os << '{';
  for (auto it = c.begin(); it != c.end(); ++it) {
    if (it != c.begin()) {
      os << ", ";
    }
    os << *it;
  }
  return os << '}';
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::stack<T, Container> s) {
  std::vector<T> v(s.size());
  for (auto it = v.rbegin(); it != v.rend(); ++it) {
    *it = s.top();
    s.pop();
  }
  return os << v;
}

template <typename T, typename Container>
std::ostream& operator<<(std::ostream& os, std::queue<T, Container> q) {
  os << '{';
  if (!q.empty()) {
    os << q.front();
    q.pop();
    while (!q.empty()) {
      os << ", " << q.front();
      q.pop();
    }
  }
  return os << '}';
}

template <typename T, typename Container, typename Compare>
std::ostream& operator<<(std::ostream& os,
                         std::priority_queue<T, Container, Compare> pq) {
  os << '{';
  if (!pq.empty()) {
    os << pq.top();
    pq.pop();
    while (!pq.empty()) {
      os << ", " << pq.top();
      pq.pop();
    }
  }
  return os << '}';
}

namespace detail {

template <int I, typename... Ts>
void tuple_print(std::ostream& os, const std::tuple<Ts...>& t) {
  static_assert(0 <= I && I <= sizeof...(Ts));
  if constexpr (I != sizeof...(Ts)) {
    if constexpr (I != 0) {
      os << ", ";
    }
    os << std::get<I>(t);
    tuple_print<I + 1>(os, t);
  }
}

}  // namespace detail

template <typename... Ts>
std::ostream& operator<<(std::ostream& os, const std::tuple<Ts...>& t) {
  os << '{';
  detail::tuple_print<0>(os, t);
  return os << '}';
}

namespace detail {

template <typename T1, typename... Ts>
void debug_print(std::string_view keys, const T1& val1, const Ts&... vals) {
  if constexpr (sizeof...(Ts) == 0) {
    std::cerr << keys << " = " << val1 << std::endl;
  } else {
    for (int i = 0, paren = 0; i < (int)keys.size(); ++i) {
      if (keys[i] == '(' || keys[i] == '{') {
        ++paren;
      } else if (keys[i] == ')' || keys[i] == '}') {
        --paren;
      } else if (keys[i] == ',' && paren == 0) {
        std::cerr << keys.substr(0, i) << " = " << val1 << ',';
        return debug_print(keys.substr(i + 1), vals...);
      }
    }
  }
}

template <typename... Ts>
void debug_print(int line, const Ts&... keyvals) {
  if constexpr (sizeof...(Ts) <= 1) {
    std::cerr << "  " << line << " |" << std::endl;
  } else {
    std::cerr << "  " << line << " | ";
    debug_print(keyvals...);
  }
}

}  // namespace detail

#if defined(TYLER) && defined(__GNUC__) && __GNUC__ >= 8
#define debug(...) \
  detail::debug_print(__LINE__, #__VA_ARGS__ __VA_OPT__(, ) __VA_ARGS__)
#elif defined(TYLER)
#define debug(...) detail::debug_print(__LINE__, #__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) ((void)0)
#endif

constexpr int MODULUS = 998244353;

template <const int& Modulus = MODULUS>
class mod_int {
 public:
  constexpr mod_int() : val_(0) {}

  template <typename T>
  constexpr mod_int(T val) : val_((int)(val % Modulus)) {
    static_assert(std::is_integral_v<T>);
    if (val_ < 0) {
      val_ += Modulus;
    }
  }

  static constexpr int modulus() { return Modulus; }

  template <typename T>
  constexpr explicit operator T() const {
    return (T)val_;
  }

  constexpr mod_int& operator++() {
    if (++val_ == Modulus) {
      val_ = 0;
    }
    return *this;
  }

  constexpr mod_int operator++(int) {
    mod_int t = *this;
    ++*this;
    return t;
  }

  constexpr mod_int& operator--() {
    if (val_ == 0) {
      val_ = Modulus;
    }
    --val_;
    return *this;
  }

  constexpr mod_int operator--(int) {
    mod_int t = *this;
    --*this;
    return t;
  }

  constexpr mod_int operator+=(mod_int other) {
    if ((val_ += other.val_) >= Modulus) {
      val_ -= Modulus;
    }
    return *this;
  }

  constexpr mod_int operator-=(mod_int other) {
    if ((val_ -= other.val_) < 0) {
      val_ += Modulus;
    }
    return *this;
  }

  constexpr mod_int operator*=(mod_int other) {
    val_ = (int)((long long)val_ * other.val_ % Modulus);
    return *this;
  }

  constexpr mod_int operator/=(mod_int other) { return *this *= inv(other); }

  friend constexpr mod_int operator+(mod_int mi) { return mi; }

  friend constexpr mod_int operator-(mod_int mi) {
    if (mi.val_ != 0) {
      mi.val_ = Modulus - mi.val_;
    }
    return mi;
  }

  friend constexpr mod_int operator+(mod_int lhs, mod_int rhs) {
    return lhs += rhs;
  }

  friend constexpr mod_int operator-(mod_int lhs, mod_int rhs) {
    return lhs -= rhs;
  }

  friend constexpr mod_int operator*(mod_int lhs, mod_int rhs) {
    return lhs *= rhs;
  }

  friend constexpr mod_int operator/(mod_int lhs, mod_int rhs) {
    return lhs /= rhs;
  }

  friend constexpr bool operator==(mod_int lhs, mod_int rhs) {
    return lhs.val_ == rhs.val_;
  }

  friend constexpr bool operator!=(mod_int lhs, mod_int rhs) {
    return lhs.val_ != rhs.val_;
  }

  friend constexpr bool operator<(mod_int lhs, mod_int rhs) {
    return lhs.val_ < rhs.val_;
  }

  friend constexpr bool operator<=(mod_int lhs, mod_int rhs) {
    return lhs.val_ <= rhs.val_;
  }

  friend constexpr bool operator>(mod_int lhs, mod_int rhs) {
    return lhs.val_ > rhs.val_;
  }

  friend constexpr bool operator>=(mod_int lhs, mod_int rhs) {
    return lhs.val_ >= rhs.val_;
  }

  friend std::ostream& operator<<(std::ostream& os, mod_int mi) {
    return os << mi.val_;
  }

  friend std::istream& operator>>(std::istream& is, mod_int& mi) {
    long long val;
    is >> val;
    mi = mod_int(val);
    return is;
  }

  friend constexpr mod_int inv(mod_int mi) {
    int a = mi.val_, b = Modulus;
    int x = 0, xx = 1;
    while (a != 0) {
      int q = b / a;
      int t = a;
      a = b - q * a;
      b = t;
      t = xx;
      xx = x - q * xx;
      x = t;
    }
    return mod_int(x);
  }

  template <typename T>
  friend constexpr mod_int pow(mod_int base, T expo) {
    static_assert(std::is_integral_v<T>);
    if (expo < 0) {
      base = inv(base);
      expo = -expo;
    }
    mod_int power = 1;
    for (; expo != 0; expo >>= 1) {
      if (expo & 1) {
        power *= base;
      }
      base *= base;
    }
    return power;
  }

 private:
  int val_;
};

// Modular combinatorics.
template <const int& Modulus = MODULUS>
class mod_comb {
 public:
  mod_comb(int n) : fact_{1}, inv_fact_{1} { resize(n); }

  mod_int<Modulus> factorial(int n) {
    if ((int)fact_.size() <= n) {
      resize(n);
    }
    return fact_[n];
  }

  mod_int<Modulus> permute(int n, int k) {
    if ((int)fact_.size() <= n) {
      resize(n);
    }
    return fact_[n] * inv_fact_[n - k];
  }

  mod_int<Modulus> choose(int n, int k) {
    if ((int)fact_.size() <= n) {
      resize(n);
    }
    return fact_[n] * inv_fact_[n - k] * inv_fact_[k];
  }

 private:
  std::vector<mod_int<Modulus>> fact_, inv_fact_;

  void resize(int n) {
    int m = (int)fact_.size();
    fact_.reserve(n + 1);
    for (int i = m; i <= n; ++i) {
      fact_.push_back(fact_[i - 1] * i);
    }
    inv_fact_.resize(n + 1);
    inv_fact_[n] = inv(fact_[n]);
    for (int i = n; i > m; --i) {
      inv_fact_[i - 1] = inv_fact_[i] * i;
    }
  }
};

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  std::cerr.precision(12);
  std::mt19937 rng((std::uint_fast32_t)std::chrono::high_resolution_clock::now()
                       .time_since_epoch()
                       .count());
  int n, k;
  cin >> n >> k;
  mod_comb comb(0);
  mod_int ans;
  for (int i = 1; n / i >= k; ++i) {
    ans += comb.choose(n / i - 1, k - 1);
  }
  cout << ans << '\n';
  return 0;
}

// #pragma GCC target   ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
// #pragma GCC optimize ("Ofast,no-stack-protector")
// #pragma GCC optimize ("unroll-loops")
// #pragma GCC optimize ("fast-math")
// #pragma comment(linker, "/stack:200000000")

#include<bits/stdc++.h>
using namespace std;

typedef long long int      ll;
typedef long double        ld;
typedef unsigned long long ull;
typedef vector<ll>         vl;
typedef vector<vl>         vvl;
typedef pair<ll,ll>        pll;
typedef vector<pll>        vpll;

#define ff          first
#define ss          second
#define pb          push_back
#define mp          make_pair
#define eb          emplace_back
#define fr(i,n)     for(ll i = 0; i < n; ++i)
#define frs(i,s,n)  for(ll i = s; i < n; ++i)
#define frb(i,s,e)  for(ll i = s; i <= e; ++i)
#define rfr(i,n)    for(ll i = n-1; i >= 0; i--)
#define frbr(i,e,s) for(ll i = e; i >= s; i--)
#define all(x)      (x).begin(), (x).end()
#define sz(x)       ((ll)(x).size())

inline void __print(int x) {cerr << x;}
inline void __print(long x) {cerr << x;}
inline void __print(long long x) {cerr << x;}
inline void __print(unsigned x) {cerr << x;}
inline void __print(unsigned long x) {cerr << x;}
inline void __print(unsigned long long x) {cerr << x;}
inline void __print(float x) {cerr << x;}
inline void __print(double x) {cerr << x;}
inline void __print(long double x) {cerr << x;}
inline void __print(char x) {cerr << '\'' << x << '\'';}
inline void __print(const char *x) {cerr << '\"' << x << '\"';}
inline void __print(const string &x) {cerr << '\"' << x << '\"';}
inline void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V>
inline void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
inline void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
inline void _print() {cerr << "]\n";}
template <typename T, typename... V>
inline void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}

clock_t startTime;
inline double getCurrentTime() {return ((double)(clock() - startTime)) / CLOCKS_PER_SEC;}

#ifdef LOCAL
#define dbg(x...)      {cerr << "[" << #x << "] = ["; _print(x);}
#define dbg_arr(a,n)   {cerr << "[" << #a << "] = [ ";fr(i,n)cerr<<a[i]<<" ";cerr<<"]\n";}
#define dbg_mat(m,r,c) {cerr<<"[" <<#m<<"]:\n";fr(i,r){cerr<<"[ ";fr(j,c)cerr<<m[i][j]<<" ";cerr<<"]\n";}}
#define dbg_time()     {cerr<<endl<<"Time elapsed: "<<getCurrentTime()<<endl<<endl<<endl;}
#else
#define dbg(x...)      {}
#define dbg_arr(a,n)   {}
#define dbg_mat(m,r,c) {}
#define dbg_time()     {}
#endif

const ld PI   = 3.141592653589793;
const ld EPS  = 1e-9;
const ll MOD  = 998244353;
const ll INF  = 1e18;
const ll SINF = 1e9;
const ll MAX  = 100100;

template< const ll &mod >
struct _m_int
{
    ll val;

    _m_int(ll v = 0)
    {
        if (v < 0) v = v % mod + mod;
        if (v >= mod) v %= mod;
        val = v;
    }

    static ll inv_mod(ll a, ll m = mod) // Extended Euclidean algorithm
    {
        ll g = m, r = a, x = 0, y = 1;

        while (r != 0)
        {
            ll q = g / r;
            g %= r; swap(g, r);
            x -= q * y; swap(x, y);
        }

        return x < 0 ? x + m : x;
    }

    _m_int& operator+=(const _m_int &other)
    {
        val -= mod - other.val;
        if (val < 0) val += mod;
        return *this;
    }

    _m_int& operator-=(const _m_int &other)
    {
        val -= other.val;
        if (val < 0) val += mod;
        return *this;
    }

    static unsigned fast_mod(ull x, unsigned m = mod)
    {
        #if !defined(_WIN32) || defined(_WIN64)
                return unsigned(x % m);
        #endif
                // Optimized mod for Codeforces 32-bit machines.
                // x must be less than 2^32 * m for this to work, so that x / m fits in a 32-bit unsigned int.
                unsigned x_high = unsigned(x >> 32), x_low = unsigned(x);
                unsigned quot, rem;
                asm("divl %4\n"
                    : "=a" (quot), "=d" (rem)
                    : "d" (x_high), "a" (x_low), "r" (m));
                return rem;
    }

    _m_int& operator*=(const _m_int &other)
    {
        val = fast_mod(ull(val) * other.val);
        return *this;
    }

    _m_int& operator/=(const _m_int &other)
    {
        return *this *= other.inv();
    }

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

    _m_int& operator++()
    {
        val = val == mod - 1 ? 0 : val + 1;
        return *this;
    }

    _m_int& operator--()
    {
        val = val == 0 ? mod - 1 : val - 1;
        return *this;
    }

    _m_int operator++(int) { _m_int before = *this; ++*this; return before; }
    _m_int operator--(int) { _m_int before = *this; --*this; return before; }

    _m_int operator-() const
    {
        return val == 0 ? 0 : mod - val;
    }

    bool operator==(const _m_int &other) const { return val == other.val; }
    bool operator!=(const _m_int &other) const { return val != other.val; }

    _m_int inv() const
    {
        return inv_mod(val);
    }

    _m_int pow(ll p) const
    {
        if (p < 0)
            return inv().pow(-p);

        _m_int a = *this, result = 1;

        while (p > 0)
        {
            if (p & 1)
                result *= a;

            p >>= 1;

            if (p > 0)
                a *= a;
        }

        return result;
    }

    explicit operator ll() const { return val; }

    friend ostream& operator<<(ostream &os, const _m_int &m)
    {
        return os << m.val;
    }

    inline friend void __print(_m_int x) {cerr << x;}
};

using mint = _m_int<MOD>;

vector<mint> inverse, factorial, inv_factorial;
ll prepared_maximum = -1;

void prepare_factorials(ll maximum)
{
    static ll prepare_calls = 0;

    if (prepare_calls++ == 0)
    {
        // Make sure MOD is prime, which is necessary for the inverse algorithm below.
        for (ll p = 2; p * p <= MOD; p += p % 2 + 1)
            assert(MOD % p != 0);

        inverse = {0, 1};
        factorial = inv_factorial = {1, 1};
        prepared_maximum = 1;
    }

    if (maximum > prepared_maximum)
    {
        inverse.resize(maximum + 1);
        factorial.resize(maximum + 1);
        inv_factorial.resize(maximum + 1);

        for (ll i = prepared_maximum + 1; i <= maximum; i++)
        {
            inverse[i] = inverse[MOD % i] * (MOD - MOD / i);
            factorial[i] = i * factorial[i - 1];
            inv_factorial[i] = inverse[i] * inv_factorial[i - 1];
        }

        prepared_maximum = ll(maximum);
    }
}

mint fact(ll n)
{
    prepare_factorials(n);
    return factorial[n];
}

mint ifact(ll n)
{
    prepare_factorials(n);
    return inv_factorial[n];
}

mint ncr(ll n, ll r)
{
    if (r < 0 || r > n || n < 0) return 0;
    prepare_factorials(n);
    return factorial[n] * inv_factorial[r] * inv_factorial[n - r];
}

mint incr(ll n, ll r)
{
    assert(0 <= r && r <= n);
    prepare_factorials(n);
    return inv_factorial[n] * factorial[r] * factorial[n - r];
}

mint npr(ll n, ll r)
{
    if (r < 0 || r > n || n < 0) return 0;
    prepare_factorials(n);
    return factorial[n] * inv_factorial[n - r];
}

mint inpr(ll n, ll r)
{
    assert(0 <= r && r <= n);
    prepare_factorials(n);
    return inv_factorial[n] * factorial[n - r];
}

void pre()
{
  //factorial();
}

void solve()
{
  ll n, k;
  mint ans = 0;
  cin >> n >> k;
  frb(i, 1, n)
  {
    ans += ncr(n / i - 1, k - 1);
  }
  cout << ans << "\n";
}

signed main()
{
    startTime = clock();

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    //cout << fixed << setprecision(15);
    pre();

    ll test = 1;
    // cin >> test;
    frb(_CASE_, 1, test)
    {
      // cout << "Case #" << _CASE_ << ": ";
      //dbg(_CASE_);
      solve();
    }

    dbg_time();

    return 0;
}

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#define ll long long
#define F(i,a,b) for(int i=(a);i<=(b);i++)
#define mst(a,b) memset((a),(b),sizeof(a))
#define PII pair<int,int>
#define rep(i,x,y) for(auto i=(x);i<=(y);++i)
#define dep(i,x,y) for(auto i=(x);i>=(y);--i)
using namespace std;
template<class T>inline void rd(T &x) {
    x=0; int ch=getchar(),f=0;
    while(ch<'0'||ch>'9'){if (ch=='-') f=1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    if(f)x=-x;
}
const int inf=0x3f3f3f3f;
const int maxn=500050;
const ll p=998244353;
ll n,k,fac[maxn];
ll ksm(ll a,ll b)
{
    ll res=1%p;
    while(b)
    {
        if(b&1) res=(res*a)%p;
        a=(a*a)%p;
        b>>=1;
    }
    return res;
}
ll c(ll n,ll m)
{
    return ((fac[n]%p*ksm(fac[m],p-2)%p)*ksm(fac[n-m],p-2)%p)%p;
}
int main()
{
    cin>>n>>k;
    if(k>n) puts("0");
    else if(k==n) puts("1");
    else
    {
        fac[0]=fac[1]=1;
        for(int i=1;i<=n;i++) fac[i]=(fac[i-1]*i)%p;
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
            ll t=(n/i)-1;
            if(t<k-1) continue;
            ans=(ans+c(t,k-1))%p;
        }
        cout<<ans<<endl;
    }

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 998244353
ll qsm(ll x,ll y){
    ll a=1;
    ll base=x;
    while(y>0){
        if(y&1){
            a=(a*base)%mod;
        }
        y>>=1;
        base=(base*base)%mod;
    }
    return a;
}
ll jc[500005]={1};
ll inv[500005]={1};
ll n,k;
void ini(){
    for(int i=1;i<=500000;i++){
        jc[i]=(jc[i-1]*i)%mod;
    }
    for(int i=1;i<=500000;i++){
        inv[i]=qsm(jc[i],mod-2);
    }
}
ll c(ll x,ll y){
    if(x>y){
        return 0;
    }
    if(x==0){
        return 1;
    }
    return jc[y]*inv[x]%mod*inv[y-x]%mod;
}
int main(){
    ini();
    cin>>n>>k;
    ll ans=0;
    for(int i=1;i<=n;i++){
        ans=(ans+c(k-1,(n-i)/i))%mod;
    }
    cout<<ans;
}

#include<bits/stdc++.h>
#include <iostream>
using namespace std;

#define ll          long long long long
#define int         long long int
#define pb          push_back
#define endl        "\n"
#define sp          " "
#define mp          make_pair
#define sz(x)       (int)x.size()
#define all(x)      x.begin(),x.end()
#define forn(i,a,b)      for(int i=a;i<b;i++)
#define hell        1000000007
#define dec(n)  std::cout << std::fixed;std::cout << std::setprecision(n);
#define helll      1073741824
# define PI 3.14159265358979323846
# define bc 998244353

bool cmp(int x,int y)
{
    return x>y;
}

int min(int a,int b)
{
    if(a>=b)
    return b;
    else
    return a;
}

int max(int a,int b)
{
    if(a>=b)
    return a;
    else
    return b;
}

int ndig(int n)
{
    int l=0;
    while(n>0)
    {
        n/=10;
        l++;
    }
    return l;
}

bool isprime(int n)
{
      if (n <= 1) return false;
      if (n <= 3) return true;
      if (n % 2 == 0 || n % 3 == 0) return false;
      for (int i = 5; i * i <= n; i = i + 6)
          if (n % i == 0 || n % (i + 2) == 0)
              return false;

      return true;
}

int gcd(int x,int y)
{
    int a,b,t,gcd,lcm;
     a = x;
     b = y;

     while (b != 0)
     {
     t = b;
     b = a % b;
     a = t;
     }

     gcd = a;
     return gcd;

}

int lcm(int x,int y)
{
    int a,b,t,gcd,lcm;
     a = x;
     b = y;

     while (b != 0)
     {
     t = b;
     b = a % b;
     a = t;
     }

     gcd = a;
     lcm = (x*y)/gcd;
     return lcm;
}
int cntdiv(int n)
{
    int cnt = 0;
    for (int i = 1; i <= sqrt(n); i++) {
        if (n % i == 0)
        {
            if (n / i == i)
                cnt++;
            else
                cnt = cnt + 2;
        }
    }
    return cnt;
}

const int N=500005;
int fact[N];

void prec()
{
  fact[0]=1;
  for(int i=1;i<N;i++)
  {
    fact[i]=((i)*1ll*(fact[i-1]))%bc;
  }
}
int mul(int x, int y)
{
  return (x * 1ll * y) % bc;
}
int binpow(int x, int y)
{
  int z = 1;
  while(y > 0)
  {
    if(y % 2 == 1)
      z = mul(z, x);
    x = mul(x, x);
    y /= 2;
  }
  return z;
}

int inv(int x)
{
  return binpow(x, bc - 2);
}

int divide(int x, int y)
{
  return mul(x, inv(y));
}
int C(int x,int y)
{
  if(y>x)
    return 0;
  else
  {
    int a,b,c;
    a=fact[x]%bc;
    b=fact[x-y]%bc;
    c=fact[y]%bc;
    int d;
    d=(b*c)%bc;
    return divide(a,d)%bc;
  }
}
void solve()
{

int n,k;
cin>>n>>k;
int ans=0;
if(k>n)
{
  cout<<"0"<<'\n';
  return;
}
prec();
for(int i=1;i<=n;i++)
{
  int d;
  d=n/i;
  ans=(ans%bc+C(d-1,k-1))%bc;

}
cout<<ans<<'\n';

}

signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("INPUT.txt","r",stdin);
    freopen("OUTPUT.txt","w",stdout);
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int TEST=1;
    //cin>>TEST;
    while(TEST--)
    {
        solve();
    }
    return 0;

}

#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)
#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)

mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());

template <typename T>
inline void chkmax(T &x, T y) { if (x < y) x = y; }

template <typename T>
inline void chkmin(T &x, T y) { if (x > y) x = y; }

inline int read() {
  #define nc getchar()
  int x = 0;
  char c = nc;
  while (c < 48) c = nc;
  while (c > 47) x = x * 10 + (c ^ 48), c = nc;
  return x;
  #undef nc
}

typedef long long ll;
const int maxn = 5e5 + 10, P = 998244353;

int Inc(int x, int y) {
  return x + y < P ? x + y : x + y - P;
}

int Dec(int x, int y) {
  return x < y ? x - y + P : x - y;
}

void Add(int &x, int y) {
  x += y;
  if (x >= P) x -= P;
}

void Sub(int &x, int y) {
  x -= y;
  if (x < 0) x += P;
}

int qp(int a, int k) {
  int res = 1;
  for (; k; k >>= 1, a = 1ll * a * a % P) {
    if (k & 1) res = 1ll * res * a % P;
  }
  return res;
}

int inv[maxn], fac[maxn], ifac[maxn];

int binom(int n, int m) {
  return n < m ? 0 : 1ll * fac[n] * ifac[m] % P * ifac[n - m] % P;
}

void init() {
  fac[0] = ifac[0] = 1;
  inv[1] = fac[1] = ifac[1] = 1;
  rep(i, 2, maxn - 1) {
    inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
    fac[i] = 1ll * i * fac[i - 1] % P;
    ifac[i] = 1ll * inv[i] * ifac[i - 1] % P;
  }
}

int n, k;

int main() {
  init();
  cin >> n >> k;
  if (k == 1) return printf("%d\n", n), 0;
  int ans = 0;
  rep(i, k, n) {
    int val = binom(i - 2, k - 2);
//    printf("#%d %d\n", i, val);
    ans = (ans + 1ll * (n / i) * val) % P;
  }
  cout << ans << endl;
  return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int,int> PII;
typedef pair<ll,int> Pli;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
//typedef pair<ll,ll>P;
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
#define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
#define REP(i,n) for(int i=0;i<n;++i)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define fors(i) for(auto i:e[x]) if(i!=p)
#define ls p<<1
#define rs p<<1|1

const int N=1222222,M=12222222;
      ll MOD=998244353;
      int intINF=int(1e9);
      ll llINF=ll(2e18);
      db eps=1e-8;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};
      long double pi=acos(-1.0L);
      ld s2=sqrt(2.0);

int read()
{
   int v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

ll readll()
{
   ll v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

inline char nc()
{
    static char buf[100000],*p1,*p2;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

int rd()
{
    int x=0; char ch=nc();
    while(ch<'0'||ch>'9') ch=nc();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=nc();
    return x;
}

/*ll pw(ll x,ll y)
{
    ll res=1;
    while(y)
    {
        if(y&1) res=res*x%MOD;
        x=x*x%MOD;
        y>>=1;
    }
    return res;
}

void pr128(__int128 x)
{
	if(x<0) putchar('-'),x=-x;
	if(x<10) return putchar('0'+x),void();
	pr128(x/10),putchar('0'+(x%10));
}*/

ll fac[N],inv[N];

void predo()
{
    fac[0]=1;
    rep(i,1,1111111) fac[i]=fac[i-1]*i%MOD;
    inv[0]=inv[1]=1;
    rep(i,2,1111111) inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
    rep(i,1,1111111) inv[i]=inv[i-1]*inv[i]%MOD;
}

ll C(ll x,ll y)
{
    if(x<0||y<0||x<y) return 0;
    return fac[x]*inv[y]%MOD*inv[x-y]%MOD;
}

int n,k;

void init()
{
    n=read(),k=read();
}

void solve()
{
    if(n<k)
    {
        printf("0\n");
        return;
    }
    ll ans=0;
    rep(fi,1,n)
    {
        int tot=n/fi;
        if(tot-1<k-1) continue;
        ans=(ans+C(tot-1,k-1))%MOD;
        //printf("C(%d,%d)\n",tot-1,k-1);
    }
    printf("%I64d\n",ans);
}

int main()
{
    //freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
    //int cas=read();
    predo();
    //while(cas--)
    //{
        init();
        solve();
    //}
    return 0;
}

#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pll pair<ll,ll>
#define vpll vector< pii >
#define MOD 998244353
#define pb push_back
#define rep(i,a,b) for(ll (i) = (a); (i) < (b); (i)++)
#define all(v) (v).begin(),(v).end()
#define ff first
#define ss second
// #define make_pair mp
#define endl "\n"
using namespace std;

int fact[500100];

int add(int x, int y)
{
    x += y;
    while(x >= MOD) x -= MOD;
    while(x < 0) x += MOD;
    return x;
}

int mul(int x, int y)
{
    return (x * 1ll * y) % MOD;
}

int binpow(int x, int y)
{
    int z = 1;
    while(y > 0)
    {
        if(y % 2 == 1)
            z = mul(z, x);
        x = mul(x, x);
        y /= 2;
    }
    return z;
}

int inv(int x)
{
    return binpow(x, MOD - 2);
}

int divide(int x, int y)
{
    return mul(x, inv(y));
}

void precalc()
{
    fact[0] = 1;
    for(int i = 1; i < 500100; i++)
        fact[i] = mul(i, fact[i - 1]);
}

int C(int n, int k)
{
    if(k > n) return 0;
    return divide(fact[n], mul(fact[n - k], fact[k]));
}
int main() {
    ios_base::sync_with_stdio(0); cin.tie(NULL);

    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif

    ll t=1;
    // cin>>t;
    while(t--)
    {
        int n,k;
        int ans=0;
        cin>>n>>k;
        if(k>n) cout<<"0";
        else {
            precalc();
            for(int i=1;i<=n;i++)
            {
                int m=n/i;
                ans=add(ans,C(m-1,k-1));
                // ans%=mod;
            }
            cout<<ans;
        }
    }
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
#define ll long long
#define pb push_back
#define F first
#define S second
#define all(c)  c.begin(), c.end()
#define rep(i,n) for(int i=0 ; i<n ; i++)
#define llv vector< ll >
#define mp make_pair
#define endl "\n"
#define N (ll)1e6+10
#define M (ll)1e18
#define matrix vector<vector<ll> >
#define sz(x) (int)x.size()

ll mod = 998244353 ;
ll fac[500005];
ll power(ll x, ll y){
    ll res = 1;
    x = x % mod;

 while (y > 0){
        if (y & 1) res = (res*x) % mod;
        y = y>>1;
        x = (x*x) % mod;
    }
    return res;
}

ll modInverse(ll a){
    return power(a, mod-2);
}

ll ncr(ll n, ll r) {

   if (r==0)return 1;

    return (fac[n]* modInverse(fac[r]) % mod *
            modInverse(fac[n-r]) % mod) % mod ;
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(0);

    ll n , k , i ;
    cin >> n >> k ;
    fac[0]=1 ;

    for(i=1 ; i<=500000 ; i++){
    	fac[i] = i*fac[i-1] ;
    	fac[i]%=mod ;
    }
    ll ethan = 0 ;

    for(i=1 ; n/i >=k ; i++){
    	 ethan = (ethan + ncr(n/i-1 , k-1))%mod ;
    }

    cout << ethan ;

   return 0 ;

}

#include <iostream>

#define int long long

using namespace std;

const int N = 5e5 + 10, mod = 998244353;

int bexp(int a, int b)
{
    a %= mod;
    int res = 1;
    while (b)
    {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

int inv(int x)
{
	return bexp(x, mod - 2);
}

int f[N];

int nck(int n, int k)
{
    if (k > n) return 0;
	int res = f[n];
	res = res * inv(f[k]) % mod;
	res = res * inv(f[n - k]) % mod;
	return res;
}

int32_t main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    f[0] = 1;
    for (int i = 1; i < N; i++) f[i] = f[i - 1] * i % mod;
    int n, k;
    cin >> n >> k;
    int ans = 0;
    for (int i = 1; i <= n; ++i)
    {
        ans += nck(n / i - 1, k - 1);
        ans %= mod;
    }
    cout << ans;
    return 0;
}

//Chaos///

#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#if DEBUG && !ONLINE_JUDGE
    #define debug(args...)     (Debugger()) , args
    class Debugger
    {
        public:
        Debugger(const std::string& _separator = ", ") :
        first(true), separator(_separator){}
        template<typename ObjectType>
        Debugger& operator , (const ObjectType& v)
        {
            if(!first)
                std::cerr << separator;
            std::cerr << v;
            first = false;
            return *this;
        }
        ~Debugger() {  std::cerr << endl;}

        private:
        bool first;
        std::string separator;
    };
    template <typename T1, typename T2>
    inline std::ostream& operator << (std::ostream& os, const std::pair<T1, T2>& p)
    {
        return os << "(" << p.first << ", " << p.second << ")";
    }
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::vector<T>& v)
    {
        bool first = true;
        os << "[";
        for(unsigned int i = 0; i < v.size(); i++)
        {
            if(!first)
                os << ", ";
            os << v[i];
            first = false;
        }
        return os << "]";
    }
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::set<T>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii;
            first = false;
        }
        return os << "]";
    }
    template<typename T1, typename T2>
    inline std::ostream &operator << (std::ostream & os,const std::map<T1, T2>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii ;
            first = false;
        }
        return os << "]";
    }
#else
    #define debug(args...)
#endif
// const int mod = 1000000007;
const int mod = 998244353;
#define ok order_of_key
#define fo find_by_order
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ll long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define repp(i,n) for(int i=(0);i<(n);i++)
#define repr(i,n) for(int i=(n);i>=0;i--)
#define reprr(i,n) for(int i=(n);i>0;i--)
#define repl(i,a,b) for(ll i=(a);i<(b);i++)
#define newl cout<<'\n'
#define inf 1000000000
#define repaa(i,a) for(auto i=a.rbegin();i!=a.rend();++i)
#define pb push_back
#define test cout<<"test"<<endl
#define tc int tt;cin>>tt;while(tt--)
#define start int tt;tt=read();while(tt--)
#define startk int tt;cin>>tt;for(int kk=1;kk<=tt;kk++)
#define mem(v,i) memset(v,i,sizeof(v))//Use mem(v,60) to initialize with 10^9
#define all(x) x.begin(), x.end()
#define inf1 1e18
#define repa(i,a) for (auto i : a)
#define X first
#define Y second
#define lb lower_bound
#define ub upper_bound
#define gcd(a,b)    __gcd((a),(b))
#define lcm(a,b)    ((a)*(b)) / gcd((a),(b))
#define in(a,n) repp(jjj,n)cin>>a[jjj];
#define re(a,n) repp(jjj,n)a[jjj]=read();
#define retree(a,m) repp(i,m){int tmp1=read()-1,tmp2=read()-1;a[tmp1].eb(tmp2);a[tmp2].eb(tmp1);}
#define intree(a,m) repp(i,m){int tmp1,tmp2;cin>>tmp1>>tmp2;tmp1--,tmp2--;a[tmp1].eb(tmp2);a[tmp2].eb(tmp1);}
#define ins insert
#define case(ans) cout << "Case #" << kk << ':' << ' ' << ans << nl
#define er erase
#define sz(a) (int)(a.size())
#define print(x,n,k) repp(i,n){repp(j,k)cout<<x[i][j]<<"  ";newl;}
#define mt make_tuple
#define eb emplace_back
#define bpl(i) __builtin_popcountll(i)
#define bp(i) __builtin_popcount(i)
#define precision(x) cout << fixed << setprecision(x);
#define si set<int>
#define usi unordered_set<int>
#define sl set < ll >
#define usl unordered_set < ll >
#define sip set < ip >
#define sil set < il >
#define mi map<int , int >
#define umi unordered_map<int , int >
#define ml map < ll , ll>
#define uml unordered_map < ll , ll>
#define mip map<ip , int>
#define mmx(x1,x2) min(x1,x2) , max(x1,x2)
#define make_unique(x) sort(all((x))); (x).resize(unique(all((x))) - (x).begin())
#define mxe max_element
#define mne min_element
#define srt(v) sort(all(v))
#define rsrt(v) sort(v.rbegin(), v.rend())
#define yn {puts("YES");}else{puts("NO");}
typedef long double ld;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<ll> vl;
typedef vector < vi > vii;
typedef vector<pair<int,int>> vip;
typedef vector<pair<ll,ll>> vil;
typedef vector < vl > vll;
typedef pair<int, int> ip;
typedef pair<ll, ll> il;
typedef tuple<int,int,int> state;
typedef tuple<ll,ll,ll> statel;
const int dx[4]={1,0,0,-1};
const int dy[4]={0,1,-1,0};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const double eps = 1e-10;
const char nl = '\n';
const char sp = ' ';
#ifdef Fading
#define gc getchar
#endif
#ifndef Fading
inline char gc(){static char now[1<<16],*S,*T;if (T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}return *S++;}
#endif
inline ll read(){register ll x=0,f=1;char ch=gc();while (!isdigit(ch)){if(ch=='-')f=-1;ch=gc();}while (isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=gc();}return (f==1)?x:-x;}
template<typename T>T Min(T v) {return v;}template<typename T, typename... Args>T Min(T first, Args... args) {return min(first , Min(args...));}
template<typename T>T Max(T v) {return v;}
template<typename T, typename... Args> T Max(T first, Args... args) {return max(first , Max(args...));}
template<typename T> T mult(T v) {return v;} template<typename T, typename... Args>T mult(T first, Args... args) {return mult((first%mod * mult(args...))%mod);}
template<class T , class U> inline bool remax(T &a, U b) { return a < b ? a = b, 1 : 0; }
template<class T , class U> inline bool remin(T &a, U b) { return a > b ? a = b, 1 : 0; }
template<class A, class B> void add(A &a, B b){a += b;if(a >= mod) a -= mod;if(a < 0) a += mod;}
template<class A, class B> ll addr(A a, B b){a += b;if(a >= mod) a -= mod;if(a < 0) a += mod;return a;}
template<class T1,class T2>T2 min(T1 a,T2 b){return min((T2)a,b);}
template<class T1,class T2>T2 max(T1 a,T2 b){return max((T2)a,b);}
template<class A> void pnt(A a[],int st,int en) {rep(i,st,en) cout << a[i] << ' ' ; newl;}
template<class A> void pnt(A a[],int en) {repp(i,en) cout << a[i] << ' ' ; newl;}
template<class A> void pnt(vector<A>&a, char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A> void pnt(A &a , char tmp = '\n') {cout << a << tmp;}
template<class A> void pnt(set<A>&a , char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A> void pnt(unordered_set<A>&a, char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A ,class B> void pnt(pair<A,B>&a, char tmp = '\n'){cout << a.X << ' ' << a.Y << tmp;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v){return i>>v.X>>v.Y;}
template<typename T , typename A>void W(T v ,A &c) {pnt(v,c);}template<typename T, typename A , typename... Args>void W(T first,A &c , Args... args) {pnt(first,c) ; W(args...);}
template <class T1>void kill(T1 ans){pnt(ans);exit(0);}

ll nc2(ll a){return a * (a - 1) / 2;}
ll setbit(ll num, ll kk){ return 1LL*(num|(1LL<<kk)); }
ll unsetbit(ll num, ll kk){ return 1LL*(num&~(1LL<<kk)); }
ll invertbit(ll num, ll kk){ return 1LL*(num^(1LL<<kk)); }
bool kthbit(ll num, ll kk){ return num&(1LL<<kk); }
bool matchpar(ll a, ll b){return (a&1) == (b&1);}
ll mceil(ll a, ll b){return a/b + (ll)(a%b > 0);}
ll poww(ll a, ll b,ll m = mod){ll val = 1;a %= m;while (b > 0){if (b & 1) val = (a * val) % m;a = (a * a) % m;b >>= 1;}return val;}
ll inv(ll a){return poww(a , mod - 2);}
ll gcdll(ll x, ll y){return y == 0 ? x : gcdll(y, x % y);}
int mylog(ll x , ll y){if(x == 0) return -1;return mylog(x/y,y) + 1;}

//-----------------------------------------------------end--------------------------------------//

const int jj=5e5+5;
ll fac[jj];
void pre(){
    fac[0] = 1;
    for (int i=1 ; i<jj; i++)
    fac[i] = fac[i-1]*i%mod;
}
ll nc(int n,int r)
{
    if(n < r) return 0;
   if (r==0)
      return 1;
   return (fac[n]*inv(fac[r])%mod*inv(fac[n-r])%mod)%mod;
}

signed main()
{
    ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int n , k;
    pre();
    cin >> n >> k;
    if(k == 1) kill(n);
    ll ans = 0;
    rep(i,1,n){
        add(ans , nc(n/i - 1,k - 1));
    }
    W(ans , nl);
}

/*
auth - @sportykush
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

typedef long long int ll;
typedef long double ld;
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;

//#define mp make_pair
#define bug(v)                    cerr<<#v<<" = "<<(v)<<endl;
#define ERASE(x)                  x.erase(unique(x.begin(),x.end()),x.end())
#define pb                        emplace_back
#define vii                       vector<int>
#define vll                       vector<ll>
#define vpll                      vector< pair <ll,ll> >
#define pll                       pair <ll,ll>
#define pii                       pair <int,int>
#define pq                        priority_queue< int >
#define khtm                      "\n"
#define F                         first
#define S                         second
#define fr(i,a,n)                 for(i=a;i<n;i++)
#define mem(arr,l)                memset(arr,l,sizeof arr)
#define ALL(x)                    x.begin(), x.end()
#define frr(i,a,n)                for(i=n-1;i>=a;i--)
#define fast                      ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define testcase                  ll T; cin>>T; while(T--)

const double pi = 3.14159265359;
const int MAX = 1e6 +2;
const ll inf =  1e18;
const int N = 1010;
const ll mod = 998244353 ;
//const ll mod=1e9+7;
inline ll add(ll a,ll b){a+=b;if(a>=mod)a-=mod;return a;}
inline ll mul(ll a,ll b){return (((a+mod)%mod)*(b+mod)%mod)%mod;}
inline ll power(ll a,ll b){ll rt=1;while(b>0){if(b&1)rt=mul(rt,a);a=mul(a,a);b>>=1;}return rt;}
inline ll modInverse(ll n, ll p){ return power(n, p-2)%p; }

/*
important builtin functions
__gcd(value1, value2)
__builtin_ffs(x)
  Number of leading zeroes: __builtin_clz(x)
  Number of trailing zeroes : __builtin_ctz(x)
  Number of set bits: __builtin_popcount(x)
*/

ll i,j,k,l,m,r,n;
//ll a[MAX],b[MAX];

ll fact[MAX];
ll solve(ll num, ll k)
{
    if(k == 1) return 1;
    num--;
    ll res = fact[num];
    res = mul(res,power(fact[num-k+1], mod-2));
    res = mul(res,power(fact[k-1], mod-2));
    return res%mod;
}

int main()
{

  #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
//cout << setprecision(15) << fixed;
fast

	fact[0] = 1;
    for(i=1;i<=500000;i++) fact[i] = mul(fact[i-1],i);
    cin >> n >> k;
    if(k > n)
    {
     cout << 0;
     return 0;
 	}
    ll ans = 0;
    for(i=1;i<=n;i++) {
        if(n - i + 1 < k)
        	continue;
        ll tmp = n / i;
        if(tmp < k)
        	continue;
        ans = add(ans,solve(tmp, k));
    }
    cout << ans;

  #ifndef ONLINE_JUDGE
  cout<<"\nTime Elapsed : " << 1.0*clock() / CLOCKS_PER_SEC << " s";
  #endif

  return 0;

}

#include <bits/stdc++.h>

using namespace std;

#define forn(i, n) for (int i = 0; i < (int)(n); i++)
#define fornll(i, n) for (ll i = 0; i < (ll)(n); i++)
#define forex(i, a, b) for (int i = (int)(a); i < (int)(b); i++ )
#define forexll(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++ )
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef complex<ld> cd;
typedef vector<int> vi;
typedef vector<ld> vld;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
typedef string st;
typedef vector<string> vst;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
char dc[4] = {'N','S','E','W'};
//1e9+7, 2e5+5

#define SIZE 500005

#define MOD 998244353
ll modfactstore[SIZE*2]; 								//MS1 this, prefably pre-run with inverse.
// Extended Euclidean algorithm
ll xGCD(ll a, ll b, ll &x, ll &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }

    ll x1, y1, gcd = xGCD(b, a % b, x1, y1);
    x = y1;
    y = x1 - (long long)(a / b) * y1;
    return gcd;
}

// factorial of n modulo MOD
ll modfact(ll n) {
	if(modfactstore[n]!=-1){
		return modfactstore[n];
	}
	if(n==0){
		return 1;
	}
    ll x=modfact(n-1)*n;
    x%=MOD;
    modfactstore[n]=x;
    return x;
}

// multiply a and b modulo MOD
ll modmult(ll a, ll b) {
    return (long long)a * b % MOD;
}

// inverse of a modulo MOD
/*
ll inverse(ll a) {
	if(inversestore[a]!=0){
		return inversestore[a];
	}

    ll x, y;
    xGCD(a, MOD, x, y);
    inversestore[a]=(x+MOD)%MOD;
    return inversestore[a];
}*/

ll modpow(ll base, ll exp)
{
	ll result = 1;
	for (base %= MOD; exp; exp >>= 1) {
	if (exp & 1) result = (result * base) % MOD;
	base = (base * base) % MOD;
	}
	return result;
}

ll inverse(ll a) {
	return modpow(a,MOD-2);
}

// binomial coefficient nCk modulo MOD
ll bc(ll n, ll k)
{

	ll y=modmult(modmult(modfact(n), inverse(modfact(k))), inverse(modfact(n - k)));

    return y;
}

int main(){
		MS1(modfactstore);
		forn(i,SIZE*2){
		modfact(i);
		}
		ll answ=0;
		ll n,k;
		cin>>n>>k;
		if(k==1){
			answ++;
		}
		forn(i,n-1){
			int a1=i+1;
			int x=n/a1;
			x--;
		//	cout<<x<<k-1<<'\n';
			if(x>=k-1){
				answ+=bc(x,k-1);
			}

			answ%=MOD;
		}
		cout<<answ;

		//printf("Case #%d ",test+1);

}

//priority_queue<int,vector<int>,greater<int>> q; (remove smallest ele)
//freopen("teleport.in","r",stdin);
//freopen("teleport.out","w",stdout);

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M=5e5+5;
const int mod=998244353;
ll fac[M],inv[M];
ll Pow(ll a,ll b){
    ll t=1ll;
    while(b){
        if(b&1)
            t=(t*a)%mod;
        b>>=1;
        a=(a*a)%mod;
    }
    return t;
}
ll C(int n,int m){
    return fac[n]*inv[m]%mod*inv[n-m]%mod;
}
int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,k;
    cin>>n>>k;
    fac[0]=1;
    for(int i=1;i<=M-4;i++)
        fac[i]=1ll*fac[i-1]*i%mod;
    inv[n]=Pow(fac[n],mod-2);
    for(int i=n-1;i>=0;i--)
        inv[i]=1ll*inv[i+1]*(i+1)%mod;
    int ans=0;

    //cout<<C(5,2)<<endl;
    for(int i=1;i<=n;i++){
        int tmp=n/i-1;
        if(1+tmp>=k)
            ans=(ans+C(tmp,k-1))%mod;
    }
    cout<<ans<<endl;
    return 0;
}

#include "bits/stdc++.h"
using namespace std;

#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define pb push_back
#define f first
#define s second
#define nl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll MOD = 998244353;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

int n, k;
ll f[500001];

ll gcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = gcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll inv(ll a){
  ll x, y;
  ll g = gcd(a, MOD, x, y);
  return (x % MOD + MOD) % MOD;
}

ll choose(int n){
  return ((f[n]*inv(f[k-1]))%MOD*inv(f[n-k+1]))%MOD;
}

int main(){
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  cin.sync_with_stdio(0); cin.tie();
  cin.exceptions(cin.failbit);

  cin >> n >> k;

  f[0]=1;
  rep(i, 1, n){
    f[i]=(f[i-1]*i)%MOD;
  }

  ll ans=0;
  rep(i, 1, n){
    if(n/i<k) break;
    ans=(ans+choose(n/i-1))%MOD;
  }
  cout << ans;
}

#include "bits/stdc++.h"
using namespace std;

#define fi first
#define se second
#define endl '\n'
#define pb push_back
#define ppf pop_front
#define ppb pop_back
#define mp make_pair
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<vi> vvi;

const int MOD=998244353,N=5e5+1;
int fac[N],rfac[N];

ll fpow(ll a,ll b) {
	ll res=1;
	while (b) {
		if (b&1) res*=a,res%=MOD;
		b/=2;
		a*=a,a%=MOD;
	}
	return res;
}

ll comb(int a,int b) {return 1ll*fac[a]*rfac[b]%MOD*rfac[a-b]%MOD;}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);

	int n,k; cin>>n>>k;
	fac[0]=rfac[0]=1;
	for (int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%MOD;
	for (int i=1;i<=n;i++) rfac[i]=fpow(fac[i],MOD-2);

	int ans=0;
	for (int i=1;i<=n;i++) {
		int cnt=n/i-1;
		if (cnt<k-1) break;
		ans+=comb(cnt,k-1);
		ans%=MOD;
	}
	cout<<ans<<endl;
}

#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
long long arr[500006] ={0};

long long binary_pow(long long x, long long y)
{
	long long z = 1;
	while(y > 0)
	{
		if(y % 2 == 1)
			z = (z*x)%mod;
		x = (x*x)%mod;
		y /= 2;
	}
	return z;
}

long long inverse(long long x)
{
	return binary_pow(x,mod - 2);
}

long long divide(long long x,long long y)
{
  return (x*inverse(y))%mod;
}

long long nCr(long n, long r)
{
  return divide(arr[n],(arr[n-r]*arr[r])%mod);
}

int main()
{
  /*
  #ifndef ONLINE_JUDGE
    freopen("D:\\Project sunrise\\input.txt", "r", stdin);
    freopen("D:\\Project sunrise\\output.txt", "w", stdout);
  #endif
  */
  ios::sync_with_stdio(0);
  cin.tie(NULL);
  cout.tie(NULL);
  int i;
  arr[0] = 1;
  long long n;
  long long k;
  long long result = 0;
  cin >> n >> k;
  long long y=1;
  for(i=1;i<=n;i++)
  {
    arr[i] = (i*arr[i-1])%mod;
  }
  while(k != 1)
  {
    if(n/y >= k)
    {
      result += nCr(n/y-1,k-1);
      result = result%mod;
      //cout << "result: " << result << "\n";
      y++;
    }
    else
    {
      break;
    }
  }
  if(k==1)
  {
    cout << n;
  }
  else
  {
    cout << result;
  }
}

//https://codeforces.com/contest/1359/problem/E
//Author: BrownieTK

//#pragma GCC optimize("O3")

#include <bits/stdc++.h>
using namespace std;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

//========================Debug======================================

void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }

template <typename T, typename V>
void __print(const pair<T, V> &x)
{
    cerr << '{';
    __print(x.first);
    cerr << ',';
    __print(x.second);
    cerr << '}';
}
template <typename T>
void __print(const T &x)
{
    int f = 0;
    cerr << '{';
    for (auto &i : x)
        cerr << (f++ ? "," : ""), __print(i);
    cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v)
{
    __print(t);
    if (sizeof...(v))
        cerr << ", ";
    _print(v...);
}
#ifdef local
#define debug(x...)               \
    cerr << "[" << #x << "] = ["; \
    _print(x)
#else
#define debug(x...)
#endif

//========================TypeDefs===================================

typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ldb;

typedef pair<lli, lli> pll;
typedef pair<int, int> pii;
typedef pair<int, lli> pil;

//=========================MACROS====================================

#define pb push_back
#define popb pop_back()
#define pf push_front
#define popf pop_front()
#define si size()
#define be begin()
#define en end()
#define all(v) v.be, v.en
#define mp make_pair
#define mt make_tuple
#define acc(v) accumulate(all(v), 0)
#define F first
#define S second

#define forz(i, n) for (int i = 0; i < n; i++)
#define fore(i, m, n) for (int i = m; i <= n; i++)
#define rforz(i, n) for (int i = n - 1; i >= 0; i--)
#define rfore(i, m, n) for (int i = n; i >= m; i--)

#define deci(n) fixed << setprecision(n)
#define high(n) __builtin_popcount(n)
#define highll(n) __builtin_popcountll(n)
#define parity(n) __builtin_parity(n)
#define clz(n) __builtin_clz(n)
#define clzll(n) __builtin_clzll(n)
#define ctz(n) __builtin_ctz(n)

#define bset(a, p) ((a) | (1ll << (p)))
#define bchk(a, p) ((a) & (1ll << (p)))
#define bxor(a, p) ((a) ^ (1ll << (p)));
#define brem(a, p) (bchk(a, p) ? (bxor(a, p)) : (a))

#define lb lower_bound
#define ub upper_bound
#define er equal_range

#define findnot find_first_not_of

#define maxe *max_element
#define mine *min_element

#define mod2 1000000007
#define mod 998244353
#define PI 3.1415926535897932384
#define INF LLONG_MAX

#define gcd __gcd
#define kira ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)

#define endl "\n"
#define p0(a) cout << a << " "
#define p1(a) cout << a << endl
#define p2(a, b) cout << a << " " << b << endl
#define p3(a, b, c) cout << a << " " << b << " " << c << endl
#define p4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl

#define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define osetlli tree<lli, null_type, less<lli>, rb_tree_tag, tree_order_statistics_node_update>

#define ofk order_of_key
#define fbo find_by_order
//member functions :
//1. order_of_key(k) : number of elements sbtriectly lesser than k
//2. find_by_order(k) : k-th element in the set

//==============================FUNCTIONS===========================================

auto clk = clock();
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
void run_time()
{
#ifdef local
    cout << endl;
    cout << "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
    return;
}

inline lli power(lli x, lli y, lli p = mod)
{
    lli res = 1;
    x = x % p;
    while (y > 0)
    {
        if (y & 1)
            res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}

inline lli modadd(lli a, lli b, lli m = mod)
{
    a += b;
    if (a >= m)
        a -= m;
    return a;
}

inline lli modmul(lli a, lli b, lli m = mod)
{
    return ((a % m) * (b % m)) % m;
}

inline lli modi(lli a, lli m = mod) { return power(a, m - 2, m); }

//================================CODE=============================================
const int N = 5e5 + 5;
lli fac[N];
void fact()
{
    fac[0] = 1;
    for (int i = 1; i < N; i++)
    {
        fac[i] = (fac[i - 1] * i) % mod;
    }
    return;
}
lli ncr(lli a, lli b)
{
    if (a < b || a < 0 || b < 0)
        return 0;
    return ((fac[a] * modi(fac[b], mod)) % mod * modi(fac[a - b], mod)) % mod;
}
int main()
{
    kira;
    lli n,k;
    cin>>n>>k;
    lli ans=0;
    if(n<k)
    {
        p1(0);
        return 0;
    }
    fact();

    for(lli i=1;i<=n;i++)
    {
        lli rem=(n-i)/i;
        ans=modadd(ans,ncr(rem,k-1));
    }
    p1(ans);
    run_time();
    return 0;
}

#include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
//using namespace __gnu_pbds;
#define FOR(i,start,end) for(int i=start;i<(int)(end);i++)
#define FORE(i,start,end) for(int i=start;i<=(int)end;i++)
#define RFORE(i,start,end) for(int i = start; i>=end; i--)
#define all(a) a.begin(), a.end()
#define v vector
typedef long long ll;
typedef pair<int, int > pii;
//template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<class T> void minn(T &a, T b) { a = min(a, b); }
template<class T> void maxx(T &a, T b) { a = max(a, b); }

const ll MOD = 998244353LL;
inline ll add(ll a, ll b) { return (a + b) % MOD; }
inline ll mul(ll a, ll b) {	return (1LL * a*b) % MOD; }
inline ll pow(ll a, ll p) {
	ll ret = 1LL;
	while (p) {
		if (p & 1LL) ret = mul(ret, a);
		a = mul(a,a), p >>= 1LL;
	}
	return ret;
}
inline ll inv(ll x) { return pow(x, MOD - 2); }

ll f[500001];
ll choose(ll a, ll b){
	return mul(f[a], mul(inv(f[b]), inv(f[a-b])));
}

int main(){
	ios_base::sync_with_stdio(false); cin.tie(NULL);
	int n, k;
	cin >> n >> k;

	f[0] = 1;
	FORE(i,1,n) f[i] = mul(f[i-1], i);

	ll ans = 0;
	FORE(a,1,n){
		int l = n/a;
		if(l-1 >= k-1)
			ans = add(ans, choose(l-1,k-1));
	}
	cout << ans << "\n";
}

#include<bits/stdc++.h>
#define ios std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,n,a) for (int i=n;i>=a;i--)
#define pb push_back
#define int long long
#define ll long long
using namespace std;
const ll INF(0x3f3f3f3f3f3f3f3fll);
const int inf(0x3f3f3f3f);

/*namespace Polynomial
{
    const ll P = 998244353, g = 3, gi = 332748118;
    static int rev[1000];
    int lim, bit;
    ll add(ll a, ll b)
    {
        return (a += b) >= P ? a - P : a;
    }
    ll qpow(ll a, ll b)
    {
        ll prod = 1;
        while (b)
        {
            if (b & 1) prod = prod * a % P;
            a = a * a % P;
            b >>= 1;
        }
        return (prod + P) % P;
    }
    void calrev() {
        for (int i = 1; i < lim; i++)
            rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
    }
    void NTT(ll* A, int inv)
    {
        for (int i = 0; i < lim; i++)
            if (i < rev[i]) swap(A[i], A[rev[i]]);
        for (int mid = 1; mid < lim; mid <<= 1)
        {
            ll tmp = qpow(inv == 1 ? g : gi, (P - 1) / (mid << 1));
            for (int j = 0; j < lim; j += (mid << 1))
            {
                ll omega = 1;
                for (int k = 0; k < mid; k++, omega = (omega * tmp) % P) {
                    int x = A[j + k], y = omega * A[j + k + mid] % P;
                    A[j + k] = (x + y) % P;
                    A[j + k + mid] = (x - y + P) % P;
                }
            }
        }
        if (inv == 1) return;
        int invn = qpow(lim, P - 2);
        for (int i = 0; i < lim; i++)
            A[i] = A[i] * invn % P;
    }
    static ll x[1000], y[1000];
    void mul(ll* a, ll* b)
    {
        memset(x, 0, sizeof x);
        memset(y, 0, sizeof y);
        for (int i = 0; i < (lim >> 1); i++)
            x[i] = a[i], y[i] = b[i];
        NTT(x, 1), NTT(y, 1);
        for (int i = 0; i < lim; i++)
            x[i] = x[i] * y[i] % P;
        NTT(x, -1);
        for (int i = 0; i < lim; i++)
            a[i] = x[i];
    }
    static ll c[2][1000];
    void Inv(ll* a, int n)
    {
        int p = 0;
        memset(c, 0, sizeof c);
        c[0][0] = qpow(a[0], P - 2);
        lim = 2, bit = 1;
        while (lim <= (n << 1))
        {
            lim <<= 1, bit++;
            calrev();
            p ^= 1;
            memset(c[p], 0, sizeof c[p]);
            for (int i = 0; i <= lim; i++)
                c[p][i] = add(c[p ^ 1][i], c[p ^ 1][i]);
            mul(c[p ^ 1], c[p ^ 1]);
            mul(c[p ^ 1], a);
            for (int i = 0; i <= lim; i++)
                c[p][i] = add(c[p][i], P - c[p ^ 1][i]);
        }
        for (int i = 0; i < lim; i++)
            a[i] = c[p][i];
    }
}
using namespace Polynomial;*/

/*namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], * p1 = buf + BUF_SIZE, * pend = buf + BUF_SIZE;
        if (p1 == pend) {
            p1 = buf; pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if (pend == p1) { IOerror = 1; return -1; }
            //{printf("IO error!\n");system("pause");for (;;);exit(0);}
        }
        return *p1++;
    }
    inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
    inline void read(int& x) {
        bool sign = 0; char ch = nc(); x = 0;
        for (; blank(ch); ch = nc());
        if (IOerror)return;
        if (ch == '-')sign = 1, ch = nc();
        for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
        if (sign)x = -x;
    }
    inline void read1(ll& x) {
        bool sign = 0; char ch = nc(); x = 0;
        for (; blank(ch); ch = nc());
        if (IOerror)return;
        if (ch == '-')sign = 1, ch = nc();
        for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
        if (sign)x = -x;
    }
    inline void read(double& x) {
        bool sign = 0; char ch = nc(); x = 0;
        for (; blank(ch); ch = nc());
        if (IOerror)return;
        if (ch == '-')sign = 1, ch = nc();
        for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
        if (ch == '.') {
            double tmp = 1; ch = nc();
            for (; ch >= '0' && ch <= '9'; ch = nc())tmp /= 10.0, x += tmp * (ch - '0');
        }
        if (sign)x = -x;
    }
    inline void read(char* s) {
        char ch = nc();
        for (; blank(ch); ch = nc());
        if (IOerror)return;
        for (; !blank(ch) && !IOerror; ch = nc())*s++ = ch;
        *s = 0;
    }
    inline void read(char& c) {
        for (c = nc(); blank(c); c = nc());
        if (IOerror) { c = -1; return; }
    }
    //getchar->read
    inline void sread1(int& x) {
        char ch; int bo = 0; x = 0;
        for (ch = getchar(); ch < '0' || ch>'9'; ch = getchar())if (ch == '-')bo = 1;
        for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar());
        if (bo)x = -x;
    }
    inline void ssread1(ll& x) {
        char ch; int bo = 0; x = 0;
        for (ch = getchar(); ch < '0' || ch>'9'; ch = getchar())if (ch == '-')bo = 1;
        for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar());
        if (bo)x = -x;
    }
    inline void read1(double& x) {
        char ch; int bo = 0; x = 0;
        for (ch = getchar(); ch < '0' || ch>'9'; ch = getchar())if (ch == '-')bo = 1;
        for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar());
        if (ch == '.') {
            double tmp = 1;
            for (ch = getchar(); ch >= '0' && ch <= '9'; tmp /= 10.0, x += tmp * (ch - '0'), ch = getchar());
        }
        if (bo)x = -x;
    }
    inline void read1(char* s) {
        char ch = getchar();
        for (; blank(ch); ch = getchar());
        for (; !blank(ch); ch = getchar())*s++ = ch;
        *s = 0;
    }
    inline void read1(char& c) { for (c = getchar(); blank(c); c = getchar()); }
    //scanf->read
    inline void read2(int& x) { scanf("%d", &x); }
    inline void wread2(ll& x) {
#ifdef _WIN32
        scanf("%I64d", &x);
#else
#ifdef __linux
        scanf("%lld", &x);
#else
        puts("error:can't recognize the system!");
#endif
#endif
    }
    inline void read2(double& x) { scanf("%lf", &x); }
    inline void read2(char* s) { scanf("%s", s); }
    inline void read2(char& c) { scanf(" %c", &c); }
    inline void readln2(char* s) { gets(s); }
    //fwrite->write
    struct Ostream_fwrite {
        char* buf, * p1, * pend;
        Ostream_fwrite() { buf = new char[BUF_SIZE]; p1 = buf; pend = buf + BUF_SIZE; }
        void out(char ch) {
            if (p1 == pend) {
                fwrite(buf, 1, BUF_SIZE, stdout); p1 = buf;
            }
            *p1++ = ch;
        }
        void print(int x) {
            static char s[15], * s1; s1 = s;
            if (!x)*s1++ = '0'; if (x < 0)out('-'), x = -x;
            while (x)*s1++ = x % 10 + '0', x /= 10;
            while (s1-- != s)out(*s1);
        }
        void println(int x) {
            static char s[15], * s1; s1 = s;
            if (!x)*s1++ = '0'; if (x < 0)out('-'), x = -x;
            while (x)*s1++ = x % 10 + '0', x /= 10;
            while (s1-- != s)out(*s1); out('\n');
        }
        void gprint(ll x) {
            static char s[25], * s1; s1 = s;
            if (!x)*s1++ = '0'; if (x < 0)out('-'), x = -x;
            while (x)*s1++ = x % 10 + '0', x /= 10;
            while (s1-- != s)out(*s1);
        }
        void asprintln(ll x) {
            static char s[25], * s1; s1 = s;
            if (!x)*s1++ = '0'; if (x < 0)out('-'), x = -x;
            while (x)*s1++ = x % 10 + '0', x /= 10;
            while (s1-- != s)out(*s1); out('\n');
        }
        void print(double x, int y) {
            static ll mul[] = { 1,10,100,1000,10000,100000,1000000,10000000,100000000,
                1000000000,10000000000LL,100000000000LL,1000000000000LL,10000000000000LL,
                100000000000000LL,1000000000000000LL,10000000000000000LL,100000000000000000LL };
            if (x < -1e-12)out('-'), x = -x; x *= mul[y];
            ll x1 = (ll)floor(x); if (x - floor(x) >= 0.5)++x1;
            ll x2 = x1 / mul[y], x3 = x1 - x2 * mul[y]; print(x2);
            if (y > 0) { out('.'); for (size_t i = 1; i < y && x3 * mul[i] < mul[y]; out('0'), ++i); print(x3); }
        }
        void println(double x, int y) { print(x, y); out('\n'); }
        void print(char* s) { while (*s)out(*s++); }
        void println(char* s) { while (*s)out(*s++); out('\n'); }
        void flush() { if (p1 != buf) { fwrite(buf, 1, p1 - buf, stdout); p1 = buf; } }
        ~Ostream_fwrite() { flush(); }
    }Ostream;
    inline void print(int x) { Ostream.print(x); }
    inline void println(int x) { Ostream.println(x); }
    inline void print(char x) { Ostream.out(x); }
    inline void println(char x) { Ostream.out(x); Ostream.out('\n'); }
    inline void gprint(ll x) { Ostream.print(x); }
    inline void hprintln(ll x) { Ostream.println(x); }
    inline void print(double x, int y) { Ostream.print(x, y); }
    inline void println(double x, int y) { Ostream.println(x, y); }
    inline void print(char* s) { Ostream.print(s); }
    inline void println(char* s) { Ostream.println(s); }
    inline void println() { Ostream.out('\n'); }
    inline void flush() { Ostream.flush(); }
    //puts->write
    char Out[OUT_SIZE], * o = Out;
    inline void print1(int x) {
        static char buf[15];
        char* p1 = buf; if (!x)*p1++ = '0'; if (x < 0)*o++ = '-', x = -x;
        while (x)*p1++ = x % 10 + '0', x /= 10;
        while (p1-- != buf)*o++ = *p1;
    }
    inline void println1(int x) { print1(x); *o++ = '\n'; }
    inline void zprint1(ll x) {
        static char buf[25];
        char* p1 = buf; if (!x)*p1++ = '0'; if (x < 0)*o++ = '-', x = -x;
        while (x)*p1++ = x % 10 + '0', x /= 10;
        while (p1-- != buf)*o++ = *p1;
    }
    inline void xprintln1(ll x) { print1(x); *o++ = '\n'; }
    inline void print1(char c) { *o++ = c; }
    inline void println1(char c) { *o++ = c; *o++ = '\n'; }
    inline void print1(char* s) { while (*s)*o++ = *s++; }
    inline void println1(char* s) { print1(s); *o++ = '\n'; }
    inline void println1() { *o++ = '\n'; }
    inline void flush1() { if (o != Out) { if (*(o - 1) == '\n')*--o = 0; puts(Out); } }
    struct puts_write {
        ~puts_write() { flush1(); }
    }_puts;
    inline void print2(int x) { printf("%d", x); }
    inline void println2(int x) { printf("%d\n", x); }
    inline void print2(char x) { printf("%c", x); }
    inline void println2(char x) { printf("%c\n", x); }
    inline void wprint2(ll x) {
#ifdef _WIN32
        printf("%I64d", x);
#else
#ifdef __linux
        printf("%lld", x);
#else
        puts("error:can't recognize the system!");
#endif
#endif
    }
    inline void tprintln2(ll x) { print2(x); printf("\n"); }
    inline void println2() { printf("\n"); }
#undef OUT_SIZE
#undef BUF_SIZE
};
using namespace fastIO;*/

struct vec
{
    double x, y; vec(double X = 0, double Y = 0) :x(X), y(Y) {}vec operator+(const vec& a)const { return vec(x + a.x, y + a.y); }
    vec operator-(const vec& a)const { return vec(x - a.x, y - a.y); }void operator+=(const vec& a) { this->x += a.x, this->y += a.y; }
    void operator-=(const vec& a) { this->x -= a.x, this->y -= a.y; }vec operator*(const double& a)const { return vec(x * a, y * a); }
    vec operator/(const double& a)const { return vec(x / a, y / a); }void operator*=(const double& a) { this->x *= a, this->y *= a; }
    void operator/=(const double& a) { this->x /= a, this->y /= a; }
};

const int N = 3e5 + 10, mod = 998244353;

int pow_mod(ll x, ll n, ll mod) { ll res = 1; while (n) { if (n & 1)res = res * x % mod; x = x * x % mod; n >>= 1; }return res; }
int fac[N << 2], inv[N << 2];
int ans=0,n,k;
int CC(int x, int y)
{
    if (y > x) return 0;
    return fac[x] * inv[x - y] % mod * inv[y] % mod;
}
void init()
{
    fac[0] = inv[0] = 1;
    rep(i, 1, N * 2) fac[i] = fac[i - 1] * i % mod;
    rep(i, 1, N * 2) inv[i] = pow_mod(fac[i], mod - 2, mod);
}
signed main()
{
    ios;
    init();
    int k;
    cin >> n >> k;
    rep(i, 1, n - k + 1)
    {
        int cnt = 0;
        for (int j = i * 2; j <= n; j += i) cnt++;
        ans = (ans + CC(cnt, k - 1)) % mod;
    }
    cout << ans << '\n';
    return 0;
}

#include<bits/stdc++.h>
#define ll              long long
#define pii             pair<int, int>
#define rep(i,a,b)      for(int  i=a;i<=b;i++)
#define dec(i,a,b)      for(int  i=a;i>=b;i--)
#define forn(i, n)      for(int i = 0; i < int(n); i++)
using namespace std;
int dir[4][2] = { { 1,0 },{ 0,1 } ,{ 0,-1 },{ -1,0 } };
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int inf = 1e9;
const double pi = 3.14159265358979323846;
const double eps = 1e-6;
const ll mod =998244353;
const int N = 5e5 +5;
int sumdigit(int x)
{
	int res=0;
	while(x)
	{
		res+=x%10;
		x/=10;
	}
	return res;
}
ll gcd(ll m, ll n)
{
    return n == 0 ? m : gcd(n, m % n);
}
ll lcm(ll m, ll n)
{
    return m * n / gcd(m, n);
}
bool prime(int x) {
    if (x < 2) return false;
    for (int i = 2; i * i <= x; ++i) {
        if (x % i == 0) return false;
    }
    return true;
}
ll qpow(ll m, ll k, ll mod)
{
    ll res = 1, t = m;
    while (k)
    {
        if (k & 1)
            res = res * t % mod;
        t = t * t % mod;
        k >>= 1;
    }
    return res;
}
ll fac[N];
ll C(ll n,ll m)
{
	if(n<m) return 0;
	return fac[n]*qpow(fac[n-m]*fac[m]%mod,mod-2,mod)%mod;
}
int main()
{
    fac[0]=1;
    rep(i,1,N)
    {
    	fac[i]=fac[i-1]*i%mod;
	}
	ll sum=0;
	ll n,k;
	cin>>n>>k;
	rep(i,1,n)
	{
		sum=(sum+C((n/i)-1,k-1)%mod)%mod;
	}
	cout<<sum<<endl;
    return 0;
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define FASTIO   \
    cin.tie(0);  \
    cout.tie(0); \
    ios_base::sync_with_stdio(false)
#define ll long long int
#define F first
#define S second
#define pll pair<ll, ll>
#define vl vector<ll>
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define vpii vector<pair<int, int>>
#define vvpii vector<vpii>
#define vpll vector<pair<ll, ll>>
#define vvpll vector<vpll>
#define pb push_back
#define MOD 1000000007
#define brk cout << "\n"

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> new_data_set;

struct compare
{
    bool operator()(const pair<int, int> &a, const pair<int, int> &b) const
    {
        if ((a.S - a.F) != (b.S - b.F))
            return ((a.S - a.F) > (b.S - b.F));
        else
            return (a.F < b.F);
    }
};

const ll mod = 998244353;
const int mx = 5e5 + 10;
vl fact(mx, 1);

void add_self(ll &a, ll b)
{
    a += b;
    if (a >= mod)
        a -= mod;
}

ll mul(ll a, ll b)
{
    ll ans = (a * b) % mod;
    return ans;
}

ll modpow(ll a, ll b)
{
    if (a == 0)
        return 0;
    ll ans = 1;
    while (b > 0)
    {
        if (b % 2 == 1)
            ans = mul(ans, a);
        a = mul(a, a);
        b /= 2;
    }
    return ans;
}

ll divide(ll a, ll b)
{
    ll y = modpow(b, mod - 2);
    ll ans = mul(a, y);
    return ans;
}

ll C(ll n, ll k)
{
    if (k > n)
        return 0ll;
    return divide(fact[n], mul(fact[n - k], fact[k]));
}

int main()
{
    FASTIO;
    for (ll i = 2; i < mx; i++)
        fact[i] = (fact[i - 1] * i) % mod;
    ll n, k;
    cin >> n >> k;
    ll ans = 0;
    for (ll i = 1; i <= n; i++)
    {
        ll d = n / i;
        add_self(ans, C(d - 1, k - 1));
        //cout << ans << endl;
    }
    cout << ans;
    brk;
}

#pragma GCC optimize(3)
#include<bits/stdc++.h>
#define M 998244353
#define LL long long int
using namespace std;
int i,j,n,k,x;
LL sb[500555]={1},sum;
LL pw(int x,int y){LL i=1,j=x,k=y;while(k){i*=max((k&1)*j%M,(LL)1);i%=M;k>>=1;j=(j*j)%M;}return i;}
int main(){
	scanf("%d%d",&n,&k);
	if(k>n){puts("0");return 0;}
	if(k==n){puts("1");return 0;}
	for(i=1;i<=n;i++){
		if((n/i-1)<k-1){break;}
		x=min(k-1,n/i-k);
		for(j=1;j<=x;j++){
			sb[j]=sb[j-1]*(n/i-j)%M;
			sb[j]=sb[j]*pw(j,M-2)%M;
		}
		sum+=sb[x]%M;sum%=M;
	}
	printf("%lld",sum);
	return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <vector>
#include <map>
#include <stack>
using namespace std;
typedef long long ll;
#define pii pair<int, int>
#define mk make_pair
const int N = 1e6 + 10;
const int mod = 998244353;
ll qpow(ll a, ll x, ll mo)
{
    ll res = 1;
    while (x)
    {
        if (x & 1)
            res = 1ll * res * a % mod;
        a = 1ll * a * a % mod;
        x >>= 1;
    }
    return res;
}
int fac[N], facinv[N];
void prepare()
{
    fac[0] = 1;
    facinv[0] = 1;
    for (int i = 1; i < N; i++)
        fac[i] = 1ll * fac[i - 1] * i % mod;
    facinv[N - 1] = qpow(fac[N - 1], mod - 2, mod);
    for (int i = N - 2; i >= 1; i--)
        facinv[i] = 1ll * facinv[i + 1] * (i + 1) % mod;
}
ll C(ll n, ll i)
{
    if (i == 0)
        return 1;
    if (n <= 0)
        return 0;
    if (i > n)
        return 0;

    return 1ll * fac[n] * facinv[i] % mod * facinv[n - i] % mod;
}
int n, k;
int main()
{
    prepare();
    cin >> n >> k;

    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        ans = (ans + C(n / i - 1, k - 1)) % mod;
    }
    cout << ans << endl;
}

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include<iostream>
#include<fstream>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<queue>
#include<deque>
#include<map>
#include<unordered_map>
#include<string>
#include<stack>
#include<vector>
#include<set>
#include<iomanip>
#include <cmath>
#include <iterator>
#include <cstdint>
#include <list>
#include <memory>
#include <unordered_set>
#include <sstream>
#include <cassert>
#include <set>
#include <algorithm>
#include <numeric>
#include <bitset>
#define int long long
using namespace std;
int m = 998244353;
int f[1000000];
int pow(int a, int p)
{
	if (p == 0)
	{
		return 1;
	}
	if (p % 2)
	{
		return (a * pow(a, p - 1))%m;
	}
	int r = pow(a, p / 2);
	return (r * r) % m;
}
void main()
{
#if defined _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	std::ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int n,k;
	cin >> n >>k;
	f[0] = 1;
	for (int i = 1; i <= n; i++)
	{
		f[i] = (f[i - 1] * i) % m;
	}
	int ans = 0;
	for (int i = 1; i <= n; i++)
	{
		int kk = n / i;
		if (kk >= k)
		{
			kk--;
			ans += (((f[kk] * pow(f[kk - k + 1], m - 2))%m) * pow(f[k - 1], m - 2))%m;
		}
	}
	cout << ans%m;
}

#include <bits/stdc++.h>
using namespace std;
#define sc(x)            scanf("%d",&x)
#define scc(x)           scanf("%c",&x)
#define scl(x)           scanf("%lld",&x)
#define sz(v)	     	(v.size())
#define mem(v, d)		memset(v, d, sizeof(v))
#define oo				2000000100
#define OO				4000000000000000100
#define Ceil(x,y) ((x+y-1)/y)
#define EPS 1e-8
#define IO ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define LFT(x)  (x*2)
#define RGHT(x) (x*2+1)
const double pi=3.14159265358979323846264338327950288419716939937510582097494459;
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;

int dX[] = {0,1,0,-1,1,1,-1,-1};
int dY[] = {1,0,-1,0,1,-1,1,-1};
string alpha = "abcdefghijklmnopqrstuvwxyz";
int limit[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
ll __lcm(ll a, ll b) { return (a / __gcd(a,b)) * b; }
const int N = 500100;
const int mod = 998244353;
ll fastpower(ll a,ll x, int m=mod)
{
    if(x<=1) return (x==0? 1:a);
	ll p = fastpower(a,x>>1, m), ret = p;
	if(x&1) ret*=a,ret%=m;
	return (ret*p)%m;
}
ll modInv(ll x, ll m= mod) {
    return fastpower(x, m - 2);
}

int n,k;
ll fact[N], Invfact[N];
ll nCr(ll a, ll b){
    if(b>a) return 0;
    return (((fact[a]*Invfact[a-b])%mod)*Invfact[b])%mod;
}
void MAIN(){
    sc(n); sc(k);
    fact[0] = 1, Invfact[0] = modInv(fact[0]);
    for(int i = 1;i<=n;++i)
        fact[i] = (fact[i-1]*i)%mod, Invfact[i]= modInv(fact[i]);
    int ans = 0;
    for(int i = 1;i<=n;++i){
        int options = n/i;
        ans += nCr(options-1, k-1);
        if(ans >= mod) ans -= mod;
    }
    printf("%d\n",ans);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    //freopen("output.txt","w",stdout);
#endif
    int t = 1;
    while(t--){
        MAIN();
    }

    return 0;
}

#include<bits/stdc++.h>
#define fr(i,n) for(int i=0;i<(n);++i)
#define foor(i,a,b) for(int i=(a);i<=(b);++i)
#define rf(i,n) for(int i=(n);i-->0;)
#define roof(i,b,a) for(int i=(b);i>=(a);--i)
#define elsif else if
#define all(x) x.begin(),x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcountll
using namespace std;            typedef vector<bool> vb; typedef vector<vb>  vvb;
                                typedef vector<int>  vi; typedef vector<vi>  vvi;
typedef long long ll;           typedef vector< ll>  vl; typedef vector<vl>  vvl;
typedef unsigned long long ull; typedef vector<ull>  vu; typedef vector<vu>  vvu;
typedef double dbl;             typedef vector<dbl>  vd; typedef vector<vd>  vvd;
typedef string str;             typedef vector<str>  vs; typedef vector<vs>  vvs;
typedef pair<int,int>pii;       typedef vector<pii>vpii; typedef map<int,int>mii;
typedef pair< ll, ll>pll;       typedef vector<pll>vpll; typedef map< ll, ll>mll;
typedef pair<dbl,dbl>pdd;       typedef vector<pdd>vpdd; typedef map<dbl,dbl>mdd;
typedef pair<str,str>pss;       typedef vector<pss>vpss; typedef map<str,str>mss;
typedef pair<int, ll>pil;       typedef vector<pil>vpil; typedef map<int, ll>mil;
typedef pair< ll,int>pli;       typedef vector<pli>vpli; typedef map< ll,int>mli;
typedef pair<dbl,int>pdi;       typedef vector<pdi>vpdi; typedef map<dbl,int>mdi;
template<typename T>vector<T>&operator<<(vector<T>&v,const T t){v.push_back(t);return v;}
template<typename T>multiset<T>&operator<<(multiset<T>&m,const T t){m.insert(t);return m;}
template<typename T>set<T>&operator<<(set<T>&s,const T t){s.insert(t);return s;}
template<typename T>stack<T>&operator<<(stack<T>&s,const T t){s.push(t);return s;}
template<typename T>stack<T>&operator>>(stack<T>&s,T&t){t=s.top();s.pop();return s;}
template<typename T>queue<T>&operator<<(queue<T>&q,const T t){q.push(t);return q;}
template<typename T>queue<T>&operator>>(queue<T>&q,T&t){t=q.front();q.pop();return q;}
template<typename T,typename U>PQ<T,vector<T>,U>&operator<<(PQ<T,vector<T>,U>&q,const T t){q.push(t);return q;}
template<typename T,typename U>PQ<T,vector<T>,U>&operator>>(PQ<T,vector<T>,U>&q,T&t){t=q.top();q.pop();return q;}
template<typename T,typename U>istream&operator>>(istream&s,pair<T,U>&p){return s>>p.first>>p.second;}
istream&operator>>(istream&s,_Bit_reference b){int a;s>>a;assert(a==0||a==1);b=a;return s;}
template<typename T>istream&operator>>(istream&s,vector<T>&v){fr(i,v.size()){s>>v[i];}return s;}
template<typename T,typename U>ostream&operator<<(ostream&s,const pair<T,U>p){return s<<p.first<<" "<<p.second;}
template<typename T>ostream&operator<<(ostream&s,const vector<T>v){fr(i,v.size()){i?s<<" "<<v[i]:s<<v[i];}return s;}
template<typename T>ostream&operator<<(ostream&s,const deque<T>d){fr(i,d.size()){i?s<<" "<<d[i]:s<<d[i];}return s;}
template<typename T>_Bit_reference operator&=(_Bit_reference b,T t){return b=b&t;}
template<typename T>_Bit_reference operator^=(_Bit_reference b,T t){return b=b^t;}
template<typename T>_Bit_reference operator|=(_Bit_reference b,T t){return b=b|t;}
template<typename T,typename U>pair<T,U>operator+(pair<T,U>a,pair<T,U>b){return {a.first+b.first,a.second+b.second};}
template<typename T,typename U>pair<T,U>operator-(pair<T,U>a,pair<T,U>b){return {a.first-b.first,a.second-b.second};}
template<typename T,typename U>pair<T,U>&operator+=(pair<T,U>&a,pair<T,U>b){return a=a+b;}
template<typename T,typename U>pair<T,U>&operator-=(pair<T,U>&a,pair<T,U>b){return a=a-b;}
void print(void){cout<<"\n";}
void Print(void){cout<<endl;}
template<typename T>void print(T t){cout<<t<<"\n";}
template<typename T>void Print(T t){cout<<t<<endl;}
template<typename T,typename...U>void print(T&&t,U&&...u){cout<<t<<" ";print(forward<U>(u)...);}
template<typename T,typename...U>void Print(T&&t,U&&...u){cout<<t<<" ";Print(forward<U>(u)...);}
bool YN(bool b){print(b?"YES":"NO");return b;}bool PI(bool b){print(b?"POSSIBLE":"IMPOSSIBLE");return b;}
bool Yn(bool b){print(b?"Yes":"No");return b;}bool Pi(bool b){print(b?"Possible":"Impossible");return b;}
bool yn(bool b){print(b?"yes":"no");return b;}bool pi(bool b){print(b?"possible":"impossible");return b;}
const int e5=1e5;
const int e9=1e9;
const int MD=1e9+7;
const int md=998244353;
const ll e18=1e18;
template<typename T>str to_string(const T&n){ostringstream s;s<<n;return s.str();}
template<typename T>T&chmax(T&a,T b){return a=max(a,b);}
template<typename T>T&chmin(T&a,T b){return a=min(a,b);}
template<typename T,typename U>vector<pair<T,U>>dijkstra(const vector<vector<pair<T,U>>>&E,const U s,const T inf){using P=pair<T,U>;vector<P>d;fr(i,E.size()){d<<P{inf,i};}PQ<P,vector<P>,greater<P>>pq;pq<<(d[s]=P{0,s});while(pq.size()){P a=pq.top();pq.pop();U v=a.second;if(d[v].first>=a.first){for(P e:E[v]){if(d[v].first+e.first<d[e.second].first){d[e.second]=P{d[v].first+e.first,v};pq<<P{d[v].first+e.first,e.second};}}}}return d;}
template<typename T,typename U>map<U,pair<T,U>>dijkstra(map<U,vector<pair<T,U>>>E,const U s,const T inf){using P=pair<T,U>;map<U,P>d;for(pair<U,vector<P>>e:E){d[e.first]=P{inf,e.first};}PQ<P,vector<P>,greater<P>>pq;pq<<(d[s]=P{0,s});while(pq.size()){P a=pq.top();pq.pop();U v=a.second;if(d[v].first>=a.first){for(P e:E[v]){if(d[v].first+e.first<d[e.second].first){d[e.second]=P{d[v].first+e.first,v};pq<<P{d[v].first+e.first,e.second};}}}}return d;}
ll maxflow(vector<mil>&E,int s,int t){ll z=0;vi b(E.size(),-1);for(int i=0;;++i){static auto dfs=[&](int v,ll f,auto&dfs)->ll{if(v==t)return f;b[v]=i;for(auto&p:E[v]){if(b[p.first]<i&&p.second){if(ll r=dfs(p.first,min(f,p.second),dfs)){p.second-=r;E[p.first][v]+=r;return r;}}}return 0;};ll x=dfs(s,ll(1e18),dfs);z+=x;if(x==0)return z;}}
template<typename T>T distsq(pair<T,T>a,pair<T,T>b){return (a.first-b.first)*(a.first-b.first)+(a.second-b.second)*(a.second-b.second);}
template<typename T>T max(const vector<T>a){assert(a.size());T m=a[0];for(T e:a){m=max(m,e);}return m;}
template<typename T>T min(const vector<T>a){assert(a.size());T m=a[0];for(T e:a){m=min(m,e);}return m;}
template<typename T>T gcd(const T a,const T b){return a?gcd(b%a,a):b;}
template<typename T>T gcd(const vector<T>a){T g=a[0];for(T e:a){g=gcd(g,e);}return g;}
template<typename T>vector<T>LCS(vector<T>A,vector<T>B){int N=A.size(),M=B.size();vector<vector<pair<int,pii>>>d(N+1,vector<pair<int,pii>>(M+1));fr(i,N){fr(j,M){if(A[i]==B[j]){d[i+1][j+1]={d[i][j].first+1,{i,j}};}else{d[i+1][j+1]=max(d[i][j+1],d[i+1][j]);}}}vector<T>r;for(pii p={N,M};d[p.first][p.second].first;p=d[p.first][p.second].second){r<<A[d[p.first][p.second].second.first];}Reverse(r);return r;}
str LCS(str S,str T){vector<char>s=LCS(vector<char>(S.begin(),S.end()),vector<char>(T.begin(),T.end()));return str(s.begin(),s.end());}
template<typename T>vector<pair<T,T>>ConvexHull(vector<pair<T,T>>V){if(V.size()<=3){return V;}Sort(V);rf(i,V.size()-1)V<<V[i];vector<pair<T,T>>r;for(pair<T,T>p:V){int s=r.size();while(s>=2&&(p.second-r[s-1].second)*(p.first-r[s-2].first)<(p.second-r[s-2].second)*(p.first-r[s-1].first)){r.pop_back();--s;}r<<p;}r.pop_back();return r;}
class UnionFind{vi p,s;void extend(int N){foor(i,p.size(),N){p<<i;s<<1;}}public:UnionFind(void){}UnionFind(int N){extend(N-1);}int find(int i){extend(i);return p[i]=p[i]==i?i:find(p[i]);}void unite(int a,int b){extend(a);extend(b);if((a=find(a))!=(b=find(b))){if(s[a]>s[b]){swap(a,b);}s[b]+=s[a];p[a]=b;}}void unite(pii p){return unite(p.first,p.second);}bool same(int a,int b){extend(a);extend(b);return find(a)==find(b);}bool same(pii p){return same(p.first,p.second);}int size(int x){extend(x);return s[find(x)];}};
ll MST(vector<pair<ll,pii>>&E){Sort(E);UnionFind uf;ll z=0;for(auto&e:E){if(!uf.same(e.second)){z+=e.first;uf.unite(e.second);}}return z;}
ll strmod(const str&s,const int m){ll x=0;fr(i,s.size()){x=(x*10+s[i]-48)%m;}return x;}
vvl mul(const vvl&A,const vvl&B,const int m){vvl C;fr(y,A.size()){C<<vl(B[y].size());}fr(y,C.size()){fr(x,C[y].size()){fr(i,A[0].size()){(C[y][x]+=A[y][i]*B[i][x])%=m;}}}return C;}
vvl pow(const vvl&A,const ll n,const int m){vvl B;fr(y,A.size()){B<<vl(A.size());}if(n==0){fr(i,B.size()){B[i][i]=1;}}elsif(n%2){B=mul(A,pow(A,n-1,m),m);}else{vvl C=pow(A,n/2,m);B=mul(C,C,m);}return B;}
ll pow(const ll a,const ll n,const int m){ll t;return n?(n&1?a>=0?a%m:(m-(-a%m))%m:1)*(t=pow(a,n>>1,m),t*t%m)%m:!!a;}
ll inv(const ll x,const int p){assert(x!=0);return pow(x,p-2,p);}
ll inv(const ll x){return inv(x,MD);}
vpll fact(const int n,const int p){assert(n<p);vpll v(n+1);v[0].first=1;foor(i,1,n){v[i].first=v[i-1].first*i%p;}v[n].second=inv(v[n].first,p);roof(i,n,1){v[i-1].second=v[i].second*i%p;}return v;}
class Combination{const vpll f;const int M;public:Combination(int n,int m):f(fact(n,m)),M(m){}ll P(int n,int k){return n<0||k<0||n<k?0ll:f[n].first*f[n-k].second%M;}ll C(int n,int k){return k<0||n<k?0ll:P(n,k)*f[k].second%M;}ll H(int n,int k){return n==0&&k==0?1ll:C(n+k-1,k);}ll F(int n){return n<0?0:f[n].first;}};
ll C2(const int n){return(ll)n*~-n/2;}
ll sum(const vi a){ll s=0;for(int e:a){s+=e;}return s;}
ll sum(const vl a){ll s=0;for(ll e:a){s+=e;}return s;}
template<typename T>int MSB(T N){int r=-1;for(;N>0;N/=2){++r;}return r;}
template<typename T>class SegmentTree{vector<T>S;T(*const op)(T a,T b);const T zero;const int B;public:SegmentTree(int N,T(*f)(T a,T b),const T zero):S(1<<MSB(N-1)+2,zero),op(f),zero(zero),B(1<<MSB(N-1)+1){}SegmentTree(vector<T>v,T(*f)(T a,T b),const T zero):SegmentTree(v.size(),f,zero){fr(i,v.size()){S[S.size()/2+i]=v[i];}roof(i,S.size()/2-1,1){S[i]=op(S[i*2],S[i*2+1]);}}T calc(int l,int r){l+=B;r+=B;if(l>r){return zero;}if(l==r){return S[l];}T L=S[l],R=S[r];for(;l/2<r/2;l/=2,r/=2){if(l%2==0){L=op(L,S[l+1]);}if(r%2==1){R=op(S[r-1],R);}}return op(L,R);}void replace(int i,T x){for(S[i+=B]=x;i!=1;i/=2){if(i%2){S[i/2]=op(S[i-1],S[i]);}else{S[i/2]=op(S[i],S[i+1]);}}}void add(int i,T x){replace(i,op(S[B+i],x));}T top(){return S[1];}T get(int i){return S[i+B];}};
ll BITsum(vl&B,int i){ll z=0;while(i>0){z+=B[i];i-=i&-i;}return z;}
void BITadd(vl&B,int i,ll x){while(i<B.size()){B[i]+=x;i+=i&-i;}}
ll fib(const ll n,const int m){ll a,b,c,d,A,B,C,D;a=1;b=0;c=0;d=1;rf(i,63){A=a*a+b*c;B=a*b+b*d;C=c*a+d*c;D=c*b+d*d;if(n>>i&1){a=A;b=B;c=C;d=D;A=a+b;B=a;C=c+d;D=c;}a=A%m;b=B%m;c=C%m;d=D%m;}return b;}
vi primes(int n){vb b(n+1);vi p;foor(i,2,n){if(!b[i]){p<<i;for(int j=2*i;j<=n;j+=i){b[j]=true;}}}return p;}
vb isprime(const int n){vb v(n+1,true);v[0]=v[1]=false;foor(i,2,n){if(v[i]){for(int j=2*i;j<=n;j+=i){v[j]=false;}}}return v;}
class LCA{vvi par;vi dep;public:LCA(vvi&E,int root):par(MSB(E.size())+1,vi(E.size())),dep(E.size()){function<void(int,int)>dfs=[&](int i,int p){for(int j:E[i])if(j!=p){par[0][j]=i;dep[j]=dep[i]+1;dfs(j,i);}};par[0][root]=root;dfs(root,root);fr(i,par.size()-1){fr(j,par[0].size()){par[i+1][j]=par[i][par[i][j]];}}}int operator()(int a,int b){if(dep[a]>dep[b])swap(a,b);for(int t=dep[b]-dep[a],i=0;t;t>>=1,++i){if(t&1){b=par[i][b];}}if(a==b)return a;rf(i,par.size()){if(par[i][a]!=par[i][b]){a=par[i][a];b=par[i][b];}}return par[0][a];}int dist(int a,int b){return dep[a]+dep[b]-2*dep[operator()(a,b)];}};
vpli factor(ll N){vpli r;for(ll i=2;i*i<=N;++i){if(N%i==0){r<<pli{i,0};while(N%i==0){N/=i;++r.back().second;}}}if(N>1){r<<pli{N,1};}return r;}
vl divisors(ll n){vl r;ll m=sqrt(n);foor(i,1,m)if(n%i==0)r<<ll(i);rf(i,r.size()-(m*m==n))r<<n/r[i];return r;}
vi SuffixArray(str S){int N=S.size();vi rank(N+1),tmp(N+1),sa(N+1);fr(i,N){sa[i]=i;rank[i]=S[i];}sa[N]=N;rank[N]=-1;int k;auto cmp=[&](int&a,int&b)->bool{if(rank[a]!=rank[b])return rank[a]<rank[b];return (a+k<=N?rank[a+k]:-1)<(b+k<=N?rank[b+k]:-1);};for(k=1;k<=N;k*=2){sort(all(sa),cmp);tmp[sa[0]]=0;foor(i,1,N){tmp[sa[i]]=tmp[sa[i-1]]+cmp(sa[i-1],sa[i]);}rank=tmp;}return sa;};
template<typename T,typename U>void sort2(vector<T>&a,vector<U>&b){int N=a.size();assert(b.size()==N);vector<pair<T,U>>v;fr(i,N){v<<pair<T,U>{a[i],b[i]};}Sort(v);fr(i,N){a[i]=v[i].first;b[i]=v[i].second;}}

int main(){cin.tie(0);ios::sync_with_stdio(false);
	int N,K;cin>>N>>K;
	Combination C(N,md);
	ll z=0;
	foor(i,1,N){
		z+=C.C(N/i-1,K-1);
		z%=md;
	}
	print(z);
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
#include<algorithm>
#include<math.h>
#include<string>
#include <set>
using namespace std;
long long int mod = 998244353;
int inv(int a)
{
	return a == 1 ? 1 : (long long)(mod - mod / a) * inv(mod % a) % mod;
}
long long int c(long long int n, long long int m)
{
	if (m < 0)return 0;
	if (n < m)return 0;
	if (m > n - m)m = n - m;
	long long int up = 1, down = 1;
	for (long long int i = 0; i < m; i++)
	{
		up = up * (n - i) % mod;
		down = down * (i + 1) % mod;
	}
	return up * inv(down) % mod;
}
int main()
{
	long long int n, k, p, ans = 0;
	cin >> n >> k;
	for (long long int i = 1; k <= n / i; i++)
	{
		p = n / i;
		ans += c(p - 1, k - 1);
		ans %= mod;
	}
	cout << ans;

}

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;
using lli = long long;

int get(int n, int k, vector<int>& A) {
	if (A.size() == k) {
		vector<int> AA=A;
		if (AA[0] == 1) return 0;
		for (int i = 2; i < 1000; i++) {

			int r=i;
			for (auto Ai : AA) r %= Ai;

			while (next_permutation(AA.begin(), AA.end())) {
				int rr=i;
				for (auto Ai : AA) rr %= Ai;
				if (rr != r) return 0;
			}
		}

		for (auto Ai : A) cout << Ai << ' ';
		cout << '\n';
		return 0;
	}
	if (A.size() == 0) {
		for (int i = 1; i <= n; i++) {
			A.push_back(i);
			get(n, k, A);
			A.erase(A.end()-1);
		}
	}
	else {
		for (int i = *A.rbegin()+1; i <= n; i++) {
			A.push_back(i);
			get(n, k, A);
			A.erase(A.end() - 1);
		}
	}
	return 0;
}

const lli MOD = 998244353;

lli pow(lli a, lli b, lli MOD) {
	lli ret = 1;
	lli m = a;
	for (; b > 0;b/=2) {
		if (b & 1) {
			ret *= a;
			ret %= MOD;
		}
		a *= a;
		a %= MOD;
	}
	return ret;
}

lli nCk(int n, int k) {
	lli ret = 1;
	for (lli i = 1; i <= k; i++) {
		ret *= n - k + i;
		ret %= MOD;
		ret *= pow(i,MOD-2,MOD);
		ret %= MOD;
	}
	return ret;
}

int main() {
	int n, k;
	cin >> n >> k;

	lli ans=0;
	for (int i = 1; i <= n && i*k <= n; i++) {
		ans+=nCk(n/i-1, k-1);
		ans %= MOD;
	}
	if (k == 1) ans = n;

	cout << ans<<'\n';
}

#include<bits/stdc++.h>
#define int long long
#define ld long double
#define ri register int
#define il inline
#define mk make_pair
#define pb push_back
#define fi first
#define se second
#define pii pair<int,int>
#define vi vector<int>
#define all(x) x.begin(),x.end()
#define rep(i,a,b) for(ri i=(a);i<=(b);++i)
#define per(i,a,b) for(ri i=(a);i>=(b);--i)
#define ls (x<<1)
#define rs (x<<1|1)
#define mid (l+r>>1)
#define db(x) cout << #x << " " << x << endl
#define dd() cout << "Out put!\n"
const int mod=998244353,eps=1e-6,pi=acos(-1.0),maxn=500010;
const int inf = 0x7f7f7f7f7f7f7f7f;
using namespace std;
int inv[maxn],f[maxn];
string s;
il int qpow(int base,int m)
{
	int res = 1;
	while(m)
	{
		if(m&1)
			(res*=base)%=mod;
		(base*=base)%=mod;
		m >>= 1;
	}
	return res%mod;
}
il int C(int n,int m)
{
	return f[n]*inv[m]%mod*inv[n-m]%mod; //�����
}
signed main()
{
	ios::sync_with_stdio(0);
	int n,k;
	cin >> n >> k ;
	f[0] = inv[0]= 1;
	rep(i,1,maxn-1)
		f[i]=f[i-1]*i%mod,inv[i] = qpow(f[i],mod-2);
	int ans = 0;
	rep(i,1,n)
	{
		int x = n/i;//�������ҪΪǰ������ı���
		if(x >= k)
			(ans += C(x-1,k-1))%=mod;
	}
	cout << ans;
	return 0;
}

#include<bits/stdc++.h>

using namespace std;

#define FOR(i, j, k) for(int i = j; i <= k; i++)
#define ROF(i, j, k) for(int i = j; i >= k; i--)
#define PB push_back
#define MEM(n, val) memset((n), val, sizeof(n))
#define FastIO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define F first
#define S second
#define MP make_pair
#define LL long long
#define MOD 998244353
#define MX 200010
#define INFL 1000000000000000000LL
#define INF 1000000000

typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;

#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace __gnu_pbds;

LL fact[500010], ufact[500010];

LL nCr(int n, int r) {
    if(n < r) {
        return 0;
    }
    LL yo = (fact[n] * ufact[r]) % MOD;
    yo = (yo * ufact[n - r]) % MOD;

    return yo;
}

LL bm(LL base, LL power) {    //bm represents bigmod
    if(power == 0)  {
        return 1;
    }
    if(power % 2 == 0)  {
        LL ret = bm(base, power / 2);
        return (ret * ret) % MOD;
    }
    else    {
        return (base * bm(base, power - 1)) % MOD;
    }
}

LL mod_inv(LL num)   {
    //fermat's little theorem
    //modu should be prime to use fermat
    return bm(num, MOD - 2);
}

int main()  {
//    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);tt
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    FastIO;

    fact[0] = 1;
    ufact[0] = mod_inv(fact[0]) % MOD;
    FOR(i, 1, 500002) {
        fact[i] = (fact[i - 1] * (LL)i) % MOD;
        ufact[i] = mod_inv(fact[i]) % MOD;
    }
    int n, k;
    cin >> n >> k;
    LL ans = 0;

//    ans = (ans + nCr((n / 1) - 1, k - 1)) % MOD;
//    FOR(i, 0, (int)prime.size() - 1) {
    FOR(i, 1, n) {
//        cout << "pr " << i << " " << (n / i) - 1 << " " << k - 1 << "\n";
        ans = (ans + nCr((n / i) - 1, k - 1)) % MOD;
    }
    cout << ans;
    return 0;
}
/**
*/

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define N 500005
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
int read(){
	int w=0,f=1;
	char c=' ';
	while(c<'0'||c>'9')c=getchar(),f=c=='-'?-1:f;
	while(c>='0'&&c<='9')w=w*10+c-48,c=getchar();
	return w*f;
}
int a[N]={1};
const int mod=998244353;
int pown(int a,int b){
	int res=1,ans=a;
	while(b){
		if(b&1)res=res*ans%mod;
		ans=ans*ans%mod;
		b>>=1;
	}
	return res;
}
int cal(int x,int y){
	return a[x]*pown(a[y],mod-2)%mod*pown(a[x-y],mod-2)%mod;
}
void init(){
	for(int i=1;i<N;i++)
		a[i]=a[i-1]*i%mod;
}
signed main(){
	init();
	int n,k,ans=0;
	n=read(),k=read()-1;
	for(int i=1;i<=n;i++)
		ans=(ans+(k>(n/i-1)?0:cal(n/i-1,k)))%mod;
	printf("%lld",ans);
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
ll fact[500001];
ll p=998244353;
ll power(ll x, ll y, ll p)
{
    ll res = 1;
    x = x % p;

    while (y > 0) {
        if (y & 1)
            res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}
ll modInverse(ll n, ll p)
{
    return power(n, p - 2, p);
}
ll cal(ll n,ll r)
{
    if (r == 0)
        return 1;

    return (fact[n] * modInverse(fact[r], p) % p * modInverse(fact[n - r], p) % p) % p;
}
int main(){
    ll n,k,temp,sum=0;
    cin>>n>>k;
    fact[0]=1;
    for(int i=1;i<=n;i++){
        fact[i]=(fact[i-1]*i)%p;
    }
    for(int i=1;i<=n;i++){
        temp=n/i-1;
        if(temp>=k-1)
            sum=(sum+cal(temp,k-1))%p;
    }
    cout<<sum<<"\n";
}

#include "bits/stdc++.h"
using namespace std;

/////////////////// TYPES & MACROS ///////////////////////////////
#define all(x) x.begin(), x.end()
#define exist(s, e) (s.find(e) != s.end())
using i64 = int64_t;
using i32 = int32_t;
const char el = '\n';
template <class T>
constexpr inline i32 SZ(const T &x) { return x.size(); }
template <class T>
constexpr inline bool rmn(T &a, T b) { return a > b ? (a = b, true) : false; }
template <class T>
constexpr inline bool rmx(T &a, T b) { return a < b ? (a = b, true) : false; }
const i32 MOD = 1e9 + 7, INF = 0x3f3f3f3f;
const i64 INFLL = ((i64)INF << 32) | INF;

//////////////////// DEBUG /////////////////////////////////////////
#ifdef LOCAL
template <class... Args>
void dprint(Args... args) { ((std::cerr << args << ", "), ...) << el; }
#else
template <class... Args>
void dprint(Args... args) {}
#endif
template <class... Args>
void print(Args... args) { (std::cout << ... << args) << el; }

/////////////////// VARIABLES & FUNCTIONS//////////////////////////
vector<vector<i32>> adj;
vector<i32> vis, color;
template <int MOD = 1'000'000'007>
struct Modular {
    int32_t value;

    Modular(long long v = 0) {
        value = v % MOD;
        if (value < 0) value += MOD;
    }
    Modular(long long a, long long b) : value(0) {
        *this += a;
        *this /= b;
    }
    Modular &operator+=(Modular const &b) {
        value += b.value;
        if (value >= MOD) value -= MOD;
        return *this;
    }
    Modular &operator-=(Modular const &b) {
        value -= b.value;
        if (value < 0) value += MOD;
        return *this;
    }
    Modular &operator*=(Modular const &b) {
        value = (long long)value * b.value % MOD;
        return *this;
    }

    friend Modular mexp(Modular a, long long e) {
        Modular res = 1;
        while (e) {
            if (e & 1) res *= a;
            a *= a, e >>= 1;
        }
        return res;
    }
    friend Modular inverse(Modular a) {
        int phi = MOD - 1; // change this for general MOD where a^phi = 1 (mod MOD)
        return mexp(a, phi - 1);
    }

    Modular &operator/=(Modular const &b) { return *this *= inverse(b); }
    friend Modular operator+(Modular a, const Modular b) { return a += b; }
    friend Modular operator-(Modular a, const Modular b) { return a -= b; }
    friend Modular operator-(const Modular a) { return 0 - a; }
    friend Modular operator*(Modular a, const Modular b) { return a *= b; }
    friend Modular operator/(Modular a, const Modular b) { return a /= b; }
    friend std::ostream &operator<<(std::ostream &os, const Modular &a) { return os << a.value; }
    friend std::istream &operator>>(std::istream &is, Modular &a) {
        long long temp;
        is >> temp;
        a = Modular(temp);
        return is;
    }
    friend bool operator==(Modular const &a, Modular const &b) { return a.value == b.value; }
    friend bool operator!=(Modular const &a, Modular const &b) { return a.value != b.value; }
};
template <int N = 1'000'000, int MOD = 998244353>
struct combinatorics {
    Modular<MOD> fac[N + 1], inv[N + 1];
    constexpr combinatorics() : fac{}, inv{} {
        fac[0] = 1;
        for (int i = 1; i <= N; ++i)
            fac[i] = i * fac[i - 1];
        inv[N] = mexp(fac[N], MOD - 2);
        for (int i = N - 1; i >= 0; i--)
            inv[i] = (i + 1) * inv[i + 1];
    }
    int32_t factorial(int n) const { return fac[n]; }
    int32_t inverse_factorial(int n) const { return inv[n]; }
    int32_t nCr(int n, int r) const {
        return (fac[n] * inv[r] * inv[n - r]).value;
    }
};

///////////////////// MAIN STARTS //////////////////////////////////
int32_t main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(13), cerr << fixed << setprecision(3);

    combinatorics<500'000, 998244353> obj;
    int n, k;
    cin >> n >> k;
    Modular<998244353> ans = 0;
    for (int i = 1; n / i >= k; ++i) {
        ans += obj.nCr(n / i - 1, k - 1);
    }
    cout << ans << el;

    return 0;
}

#include <bits/stdc++.h>
#define R register int
#define ll long long
using namespace std;
const ll P=998244353;
ll ksm(ll a,ll b)
{
	ll ans=1;
	a%=P;
	while(b)
	{
		if(b&1)ans=(ans*a)%P;
		b>>=1;
		a=(a*a)%P;
	}
	return ans;
}
ll inv(ll a)
{
	return ksm(a,P-2);
}
ll C(ll n,ll m)
{
    if(m>n)return 0;
    ll up=1,down=1;
    for(R i=n-m+1;i<=n;i++)up=up*i%P;
    for(R i=1;i<=m;i++)down=down*i%P;
    return up*inv(down)%P;
}
ll lucas(ll n,ll m)
{
	//cout<<n/P<<" "<<m/P<<endl;
	if(m>n)return 0;
	if(m==0)return 1;
	return C(n%P,m%P)*lucas(n/P,m/P)%P;
}
int main()
{
	int n,m;
	ll ans=0;
	scanf("%d%d",&n,&m);
	for(R i=1;i<=n;i++)
	{
		int x=n/i-1,y=m-1;
		ans=(ans+lucas(x,y))%P;
	}
	printf("%lld\n",ans);
	return 0;
}

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <stdio.h>
#include <tuple>
#include <bitset>
#include <cfloat>
#include <fstream>
#include <limits.h>
#include <list>
#include <math.h>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <numeric>
#include <utility>
#include <sstream>
#include <cassert>
template<class T> inline bool chmin(T& a, T b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template<class T> inline bool chmax(T& a, T b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
using namespace std;
#define int long long
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define P pair<ll, ll>
#define sz(x) (ll)x.size()
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define VE vector<ll>
#define COUT(x) cout<<(x)<<endl
#define MA map<ll,ll>
#define SE set<ll>
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,VE,greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO"  ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No"  ) << endl
#define EPS (1e-10)
#define pb push_back
//long long MOD = 1000000007;
long long MOD = 998244353;
const long long INF = 1LL << 60;
const long double PI = acos(-1.0);
struct mint {
	ll x; // typedef long long ll;
	mint(ll x = 0) :x((x%MOD + MOD) % MOD) {}
	mint operator-() const { return mint(-x); }
	mint& operator+=(const mint a) {
		if ((x += a.x) >= MOD) x -= MOD;
		return *this;
	}
	mint& operator-=(const mint a) {
		if ((x += MOD - a.x) >= MOD) x -= MOD;
		return *this;
	}
	mint& operator*=(const mint a) {
		(x *= a.x) %= MOD;
		return *this;
	}
	mint operator+(const mint a) const {
		mint res(*this);
		return res += a;
	}
	mint operator-(const mint a) const {
		mint res(*this);
		return res -= a;
	}
	mint operator*(const mint a) const {
		mint res(*this);
		return res *= a;
	}
	mint pow(ll t) const {
		if (!t) return 1;
		mint a = pow(t >> 1);
		a *= a;
		if (t & 1) a *= *this;
		return a;
	}
	// for prime MOD
	mint inv() const {
		return pow(MOD - 2);
	}
	mint& operator/=(const mint a) {
		return (*this) *= a.inv();
	}
	mint operator/(const mint a) const {
		mint res(*this);
		return res /= a;
	}
	bool operator==(const mint a) const {
		return x == a.x;
	}
	bool operator!=(const mint a) const {
		return x != a.x;
	}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
struct Sieve {
	int n;
	vector<int> f, primes;

	Sieve(int n = 1) :n(n), f(n + 1) {
		f[0] = f[1] = -1;
		for (ll i = 2; i <= n; ++i) {
			if (f[i]) continue;
			primes.push_back(i);
			f[i] = i;
			for (ll j = i * i; j <= n; j += i) {
				if (!f[j]) f[j] = i;
			}
		}
	}

	bool isPrime(int x) { return f[x] == x; }

	vector<int> factorList(int x) {
		vector<int> res;
		while (x != 1) {
			res.push_back(f[x]);
			x /= f[x];
		}
		return res;
	}

	vector<P> factor(int x) {
		vector<int> fl = factorList(x);
		if (fl.size() == 0) return {};
		vector<P> res(1, P(fl[0], 0));
		for (int p : fl) {
			if (res.back().first == p) {
				res.back().second++;
			}
			else {
				res.emplace_back(p, 1);
			}
		}
		return res;
	}
};
template<class t> t gcd(t a, t b) {
	return b != 0 ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) {
	ll g = gcd(a, b);
	return a / g * b;
}
bool prime(ll n) {
	for (ll i = 2; i <= sqrt(n); i++) {
		if (n%i == 0)return false;
	}
	return n != 1;
}
map<ll, ll> prime_factor(ll n) {
	map<ll, ll> ret;
	for (ll i = 2; i * i <= n; i++) {
		while (n % i == 0) {
			ret[i]++;
			n /= i;
		}
	}
	if (n != 1) ret[n] = 1;
	return ret;
}
ll modinv(ll a, ll m) {
	ll b = m, u = 1, v = 0;
	while (b) {
		ll t = a / b;
		a -= t * b; swap(a, b);
		u -= t * v; swap(u, v);
	}
	u %= m;
	if (u < 0) u += m;
	return u;
}
vector<pair<char, int>> RunLength(string s) {
	if (s.size() == 0)return {};
	vector<pair<char, int>>res(1, pair<char, int>(s[0], 0));
	for (char p : s) {
		if (res.back().first == p) {
			res.back().second++;
		}
		else {
			res.emplace_back(p, 1);
		}
	}
	return res;
}
// Digit Count
int GetDigit(int num) {
	return log10(num) + 1;
}
// bit calculation[how many "1"] (= __builtin_popcount())
int bit_count(int n) {
	int cnt = 0;
	while (n > 0) {
		if (n % 2 == 1)cnt++;
		n /= 2;
	}
	return cnt;
}
vector<long long> enum_divisors(long long N) {
	vector<long long> res;
	for (long long i = 1; i * i <= N; ++i) {
		if (N % i == 0) {
			res.push_back(i);
			if (N / i != i) res.push_back(N / i);
		}
	}
	sort(res.begin(), res.end());
	return res;
}
const ll dx[4] = { 1,0,-1,0 };
const ll dy[4] = { 0,1,0,-1 };
//struct edge { ll to, cost; };
typedef long double ld;
using Graph = vector<vector<int>>;
class UnionFind {
public:
	vector <ll> par; // 各元の親を表す配列
	vector <ll> siz; // 素集合のサイズを表す配列(1 で初期化)

	// Constructor
	UnionFind(ll sz_) : par(sz_), siz(sz_, 1) {
		for (ll i = 0; i < sz_; ++i) par[i] = i; // 初期では親は自分自身
	}
	void init(ll sz_) {
		par.resize(sz_);
		siz.resize(sz_, 1);
		for (ll i = 0; i < sz_; ++i) par[i] = i; // 初期では親は自分自身
	}

	// Member Function
	// Find
	ll root(ll x) { // 根の検索
		while (par[x] != x) {
			x = par[x] = par[par[x]]; // x の親の親を x の親とする
		}
		return x;
	}

	// Union(Unite, Merge)
	bool merge(ll x, ll y) {
		x = root(x);
		y = root(y);
		if (x == y) return false;
		// merge technique（データ構造をマージするテク．小を大にくっつける）
		if (siz[x] < siz[y]) swap(x, y);
		siz[x] += siz[y];
		par[y] = x;
		return true;
	}

	bool issame(ll x, ll y) { // 連結判定
		return root(x) == root(y);
	}

	ll size(ll x) { // 素集合のサイズ
		return siz[root(x)];
	}
};
struct combination {
	vector<mint> fact, ifact;
	combination(int n) :fact(n + 1), ifact(n + 1) {
		//assert(n < mod);
		fact[0] = 1;
		for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
		ifact[n] = fact[n].inv();
		for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
	}
	mint operator()(int n, int k) {
		if (k < 0 || k > n) return 0;
		return fact[n] * ifact[k] * ifact[n - k];
	}
};
struct edge { int to, cost; };

signed main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	//cout << fixed << setprecision(20);
	combination com(500010);
	int t; t = 1;
	rep(_, t) {
		int n, k; cin >> n >> k;
		mint ans = 0;
		for (int i = 1; i <= n; i++) {
			ans += com(n / i - 1, k - 1);
		}
		cout << ans << endl;
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define imt long long
const int MX = 1e6 + 1, MOD = 998244353;
int a[MX], n, k, h, c, m, x, y, ans = 0;
int fact[MX];
int add(int x, int y){
    x = x + y;
    while(x >= MOD) x -= MOD;
    while(x < 0) x += MOD;
    return x;
}
int mul(int x, int y){
    return (x * 1ll * y) % MOD;
}
int pow(int x, int y){
    int z = 1;
    while(y > 0){
        if(y & 1) z = mul(z, x);
        x = mul(x, x);
        y = y / 2;
    }
    return z;
}
int inv(int x){
    return pow(x, MOD - 2);
}
int divide(int x, int y){
    return mul(x, inv(y));
}
void precal(){
    fact[0] = 1;
    for(int i = 1; i < MX; i++) fact[i] = mul(fact[i - 1], i);
}
int C(int n, int k){
    if(n < k) return 0;
    return divide(fact[n], mul(fact[k], fact[n - k]));
}
int32_t main()
{
//    ios_base::sync_with_stdio(false);
//    cin.tie(NULL);
    /*
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    */
    int t = 1;
//    cin>>t;
    while(t--){
        cin>>n>>k;
        precal();
        long long ans = 0;
        for(int i = 1; i <= n; i++){
            int d = n / i;
            ans = add(ans, C(d - 1, k - 1));
        }
        cout<<ans<<"\n";
    }
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ff(i,n) for(i=1;i<=n;i++)
#define pb push_back
ll bg =  998244353;
ll fac[600000];
ll power(ll x,ll y)
{
    if(y==0)
	    return 1;
	ll d = power(x,y/2)%bg;
	ll f = (d*d)%bg;
	if(y%2==0)
	  return f;
	else
	  return (f*x)%bg;
}
ll modinv(ll m)
{
	return power(m,bg-2);
}
ll ncr(ll n,ll r)
{
         if(n<r)
             return 0;
	ll s1 = fac[n],s2 = fac[r],s3 = fac[n-r];
	ll d1 = (s1*modinv(((s2*s3)%bg)))%bg;
	return d1;
}
int main()
{
	fac[0]=1;
	for(ll j=1;j<600000;j++)
	  fac[j] = (j*fac[j-1])%bg;
	ll i,j,n,k,ans=0;
	cin>>n>>k;
	ff(i,n)
	    ans=(ans+ncr((n/i)-1,k-1))%bg;
	cout<<ans<<endl;
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ff(i,n) for(i=1;i<=n;i++)
#define pb push_back
ll bg =  998244353;
ll fac[600000];
ll power(ll x,ll y)
{
    if(y==0)
	    return 1;
	ll d = power(x,y/2)%bg;
	ll f = (d*d)%bg;
	if(y%2==0)
	  return f;
	else
	  return (f*x)%bg;
}
ll modinv(ll m)
{
	return power(m,bg-2);
}
ll ncr(ll n,ll r)
{
         if(n<r)
             return 0;
	ll s1 = fac[n],s2 = fac[r],s3 = fac[n-r];
	ll d1 = (s1*modinv(((s2*s3)%bg)))%bg;
	return d1;
}
int main()
{
	fac[0]=1;
	for(ll j=1;j<600000;j++)
	  fac[j] = (j*fac[j-1])%bg;
	ll t;
	t=1;
	while(t--)
	{
		ll i,j,n,k;
		cin>>n>>k;
		if(k>n)
		{
			cout<<"0";
			return 0;
		}
		ll ans = 0;
		ff(i,n)
		    ans=(ans+ncr((n/i)-1,k-1))%bg;
		cout<<ans<<endl;
	}
	 return 0;
}

/*
* sto RainAir,Logey,Shq,HandwerSTD,Herself32,Zyque,MoveToEX,Liuzhe,uliahradri,Extmool orz
* 感谢真神们无私的教诲。
* 膜真神者处处阿克，只因大师们在他背后。
* 不膜真神者将违背真神的旨意，真神必将降下天谴，使其天天爆零
* 因此,我不由自主地膜拜真神们 orz。
*											——Payphone-X
*/
#include <algorithm>
#include <iostream>
#include <cstring>
#include <iomanip>
#include <cstdlib>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <cctype>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <map>
#include <set>

#define I inline
#define ll long long
#define pb push_back
#define MP make_pair
#define ull unsigned long long
#define PII pair<int , int>
#define PIL pair<int , long long>
#define PSL pair<string , long long>
#define PLL pair<long long , long long>
#define all(x) (x).begin() , (x).end()
#define copy(a , b) memcpy(a , b , sizeof(b))
#define clean(a , b) memset(a , b , sizeof(a))
#define rep(i , l , r) for (int i = (l); i <= (r); i ++)
#define per(i , r , l) for (int i = (r); i >= (l); i --)
#define PE(i , x) for(int i = head[x]; i; i = edge[i].last)
#define DEBUG(x) std :: cerr << #x << '=' << x << std :: endl

using namespace std;

const int N = 10001;
const int M = 1000001;
const int HA = 998244353;
const int INF = 2147483647;
const long long INFL = 9223372036854775807;

#define int ll

int n , k;
int inv[M] , fac[M];

int Pow(int a , int b){
    if(b == 0) return 1;
    if(b == 1) return a % HA;
    int mid = Pow(a , b >> 1) % HA;
    if(b % 2 == 0){
        return (mid * mid) % HA;
    }
    else{
        return (mid * mid) % HA * a % HA;
    }
}

int BINOM(int n , int m){
    if(n < m) return 0;
    return 1ll * fac[n] * inv[m] % HA * inv[n - m] % HA;
}

signed main() {
    #ifdef LOCAL
        freopen("try.in" , "r" , stdin);
        freopen("try1.out" , "w" , stdout);
    #endif
    scanf("%d%d" , &n , &k);
    fac[0] = 1;
    rep(i , 1 , M - 1){
        fac[i] = (ll)fac[i - 1] * i % HA;
    }
    inv[M - 1] = Pow(fac[M - 1] , HA - 2);
    per(i , M - 2 , 0){
        inv[i] = inv[i + 1] * (i + 1) % HA;
    }
    DEBUG(inv[M - 1] * fac[M - 1] % HA);
        DEBUG(BINOM(3 , 2));
    int ans = 0;
    rep(i , 1 , n){
        (ans += 1ll * BINOM(n / i - 1 , k - 1)) %= HA;
    }
    printf("%d\n" , ans);

    return 0;
}

#include<bits/stdc++.h>

using namespace std;
#define int long long
#define mod 998244353
#define N 500005

int n, k;
int fact[N];

void get_fact() {
    fact[0] = 1;
    for(int i = 1;i <= n;i++)
        fact[i] = (fact[i-1]*i)%mod;
}

int modpow(int x, int y) {
    if(y==0) return 1;
    int u = modpow(x, y/2);
    u = (u*u)%mod;
    if(y%2) u = (u*x)%mod;
    return u;
}

int nCk(int x, int y) {
    if(x == 1 || x == y) return 1;
    if(x > y) return 0;

    int res = fact[y];
    res = (res*modpow(fact[x], mod-2))%mod;
    res = (res*modpow(fact[y-x], mod-2))%mod;

    return res;
}
signed main() {
    cin >> n >> k;

    if(n < k) { cout << 0; return 0; }
    get_fact();

    int ans = 0;
    for(int i = 1;i <= n;i++) {
        int d = n/i;
        ans = (ans+nCk(k-1, d-1))%mod;
    }

    cout << ans;
    return 0;
}

/**** [ AkJn ] ****/
#include <bits/stdc++.h>
using namespace std;

#define fastIO ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
#define endl '\n'
#define all(x) (x).begin(),(x).end()
#define vi vector<ll>
#define vii vector <pair<ll,ll> >
#define pb push_back
#define mp make_pair
#define ld long double
#define ll long long
#define min3(a, b, c) min(a,min(b, c))
#define min4(a, b, c, d) min(a, min(b, min(c, d)))
#define max3(a, b, c) max(a,max(b, c))
#define max4(a, b, c, d) max(a, max(b, max(c, d)))
#define yay(x) cerr<<endl<<"yay"<<x<<endl;
#define yay1 cerr<<"yay1"<<endl;
#define yay2 cerr<<"yay2"<<endl;
#define yay3 cerr<<"yay3"<<endl;
#define yay4 cerr<<"yay4"<<endl;
#define dbg(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define dbgendl(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); cerr<<endl;}
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
    cerr << *it << " = " << a << endl;
    err(++it, args...);
}

/*
 * THINK MATHEMATICALLY. IT IS NOT AS TOUGH AS IT SEEMS.
 * Check EDGE CASES!! Seriously, even in 2B, saving 8 points by being
 * 2 minutes faster will bite you in the ass if you don't make sure
 * it works on edge cases.
 * Pretests != Tests. READ THIS POINT AGAIN.
 * You do know how to use structs. God damn use them when required.
 * 0 is better than -1.
 * Keep adding to this list and to the custom snippets :D
 * cd /Users/AkJn/Library/Application\ Support/Sublime\ Text\ 3/Packages/User
*/

const ll inf = 1e18L + 5;

const ll mod = 998244353;
const ll N = 500043;
ll fact[N];

ll add(ll x, ll y)
{
    x += y;
    x %= mod;
    if(x < 0){
        x += mod;
    }
    return x;
}

ll mul(ll a, ll b)
{
    return ((a%mod)*(b%mod))%mod;
}

ll pow(ll a, ll b, ll m=mod)
{
    ll ans=1;
    while(b)
    {
        if(b&1)
            ans=(ans*a)%m;
        b/=2;
        a=(a*a)%m;
    }
    return ans;
}

ll inv(ll k)
{
    return pow(k, mod - 2, mod);
}

ll divide(ll x, ll y)
{
    return mul(x, inv(y));
}

void precalc()
{
    fact[0] = 1;
    for(ll i = 1; i < N; i++){
        fact[i] = mul(i, fact[i - 1]);
    }
}

ll nck(ll n, ll k)
{
    if(k > n){
        return 0;
    }
    return divide(fact[n], mul(fact[n - k], fact[k]));
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);

    fastIO
    ll testcases=1;
    // cin>>testcases;
    precalc();
    while(testcases--){
        ll n,k;
        cin>>n>>k;
        ll ans=0;
        for (ll i = 1; i <= n; ++i)
        {
            ll d = n/i;
            ans = add(ans,nck(d-1,k-1));
        }
        cout << ans << endl;
    }
    return 0;
}

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LETS_GET_SCHWIFTY ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ff              first
#define ss              second
#define int             long long
#define ll              long long
#define ld              long  double
#define pb              push_back
#define pii             pair<int,int>
#define vi              vector<int>
#define mii             map<int,int>
#define pqb             priority_queue<int>
#define pqs             priority_queue<int,vi,greater<int> >
#define setbits(x)      __builtin_popcountll(x)
#define zerobits(x)      __builtin_ctzll(x)
#define mod             998244353
#define Mod             1000000007
#define inf             1e18
#define ps(x,y)         fixed<<setprecision(y)<<x
#define vpii            vector<pair<int,int> >
#define all(x)          x.begin(),x.end()
#define matrixprint(arr,a,b,c,d) for(int i=a;i<=c;i++){for(int j=b;j<=d;j++){cout<<arr[i][j]<<" ";}cout<<"\n";}
#define show(arr,x,y)   for(int i=x;i<=y;i++){cout<<arr[i]<<" ";}cout<<"\n"
#define inc(i,x,y)      for(int i=x;i<y;i++)
#define dec(i,x,y)      for(int i=x;i>=y;i--)

const int N = 2e5 + 5;

#define TRACE
#ifdef TRACE
#define deb(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
    cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define deb(...)
#endif

//////////////////////////////code//////////////////////////////

inline int add(int x, int y) { x += y; return x % mod;}

int a,b,t;

int fac[500005];
int inv[500005];

int power(int a, int n = mod - 2)
{
	if (!n)
		return 1;
	int pt = power(a, n / 2);
	pt *= pt, pt %= mod;
	if (n & 1)
		pt *= a, pt %= mod;
	return pt;
}

int ncr(int n, int r)
{
	int ans1 = fac[n];
	int ans2 = (inv[r] * inv[n - r]) % mod;

	ans1 = (ans1 * ans2) % mod;

	return ans1;
}

void fillfac()
{
    fac[0] = inv[0] = 1;

	for (int i = 1; i <=500004; ++i)
	{
		fac[i] = (fac[i - 1] * i) % mod;
		inv[i] = power(fac[i]);
	}

}

void solve()
{
   // cout << "-------------------" << "\n";

 int n,k;cin>>n>>k;

 fillfac();

 int ans = 0;

 if(n<k)
 {
     cout<<0<<"\n";

 }
 else if(k==1)
 {
     cout<<n<<"\n";
 }
 else
 {

   for(int i=1;i<=n;i++)
  {   int cnt = n/i;
     if(cnt-1 >=k-1)
     ans += ncr(cnt-1,k-1);

     ans%=mod;

  }
    cout<<ans<<"\n";
 }

   // cout << "-------------------" << "\n";

}

int32_t main()
{

    LETS_GET_SCHWIFTY;

    int t = 1;
   // cin >> t;

    while (t--)
        solve();

}

/**** [ AkJn ] ****/
#include <bits/stdc++.h>
using namespace std;

#define fastIO ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
#define endl '\n'
#define all(x) (x).begin(),(x).end()
#define vi vector<ll>
#define vii vector <pair<ll,ll> >
#define pb push_back
#define mp make_pair
#define ld long double
#define ll long long
#define min3(a, b, c) min(a,min(b, c))
#define min4(a, b, c, d) min(a, min(b, min(c, d)))
#define max3(a, b, c) max(a,max(b, c))
#define max4(a, b, c, d) max(a, max(b, max(c, d)))
#define yay(x) cerr<<endl<<"yay"<<x<<endl;
#define yay1 cerr<<"yay1"<<endl;
#define yay2 cerr<<"yay2"<<endl;
#define yay3 cerr<<"yay3"<<endl;
#define yay4 cerr<<"yay4"<<endl;
#define dbg(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define dbgendl(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); cerr<<endl;}
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
    cerr << *it << " = " << a << endl;
    err(++it, args...);
}

/*
 * THINK MATHEMATICALLY. IT IS NOT AS TOUGH AS IT SEEMS.
 * Check EDGE CASES!! Seriously, even in 2B, saving 8 points by being
 * 2 minutes faster will bite you in the ass if you don't make sure
 * it works on edge cases.
 * Pretests != Tests. READ THIS POINT AGAIN.
 * You do know how to use structs. God damn use them when required.
 * 0 is better than -1.
 * Keep adding to this list and to the custom snippets :D
 * cd /Users/AkJn/Library/Application\ Support/Sublime\ Text\ 3/Packages/User
*/

const ll inf = 1e18L + 5;
const ll mod = 1e9+7;

const int MOD = 998244353;
const int N = 500043;
ll fact[N];

ll add(ll x, ll y)
{
    x += y;
    x %= MOD;
    if(x < 0){
        x += MOD;
    }
    return x;
}

ll mul(ll x, ll y)
{
    return (x * y) % MOD;
}

ll pow(ll a, ll b, ll m=mod)
{
    ll ans=1;
    while(b)
    {
        if(b&1)
            ans=(ans*a)%m;
        b/=2;
        a=(a*a)%m;
    }
    return ans;
}

ll inv(ll k)
{
    return pow(k, MOD - 2, MOD);
}

ll divide(ll x, ll y)
{
    return mul(x, inv(y));
}

void precalc()
{
    fact[0] = 1;
    for(ll i = 1; i < N; i++){
        fact[i] = mul(i, fact[i - 1]);
    }
}

ll nck(ll n, ll k)
{
    if(k > n){
        return 0;
    }
    return divide(fact[n], mul(fact[n - k], fact[k]));
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);

    fastIO
    ll testcases=1;
    // cin>>testcases;
    precalc();
    while(testcases--){
        ll n,k;
        cin>>n>>k;
        ll ans=0;
        for (ll i = 1; i <= n; ++i)
        {
            ll d = n/i;
            ans = add(ans,nck(d-1,k-1));
        }
        cout << ans << endl;
    }
    return 0;
}

#include <string.h>
#include <assert.h>
#include <cassert>
#include <unordered_map>

#include <sstream>
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <stack>
#include <queue>
#include <set>

#include <map>
#include <vector>
#include <string>
#include <stdlib.h>
#include <cassert>

#define ll long long
#define clr(x) memset(x,0,sizeof(x))
#define _clr(x) memset(x,-1,sizeof(x))
#define fr(i,a,b) for(int i = a; i < b; ++i)
#define frr(i,a,b) for(int i = a; i > b; --i)
#define pb push_back
#define sf scanf

#define pf printf
#define mp make_pair
#define pir pair<int,int>
#define N 611100

const int mod = 998244353;

using namespace std;

ll A[N];
ll inv[N];
ll n,k;

ll c(int n, int m) {
	if(n<m)return 0;
	//printf("n = %d m = %d a = %d\n",n,m,A[n]);
	return (((A[n] * inv[m])%mod) * inv[n-m])%mod;
}

ll pow(ll a, int b) {
	ll ret = 1;
	while(b>0) {
		if(b&1) (ret = (ret*a)%mod);
		a = (a*a)%mod;
		b>>=1;
	}
	return ret;
}

int is[N],pr[N];
int cnt;
int main(){
	A[0] = 1;
	inv[0] = 1;
	for(int i =1; i <=500000; ++i) {
		A[i] = (A[i-1]*i)%mod;
		inv[i] = pow(A[i],mod-2);
	}
	cnt = 0;
	cin>>n>>k;
	ll ans = 0;
	for(int i = 1; i <=n; ++i) {
		int num = n/i;
		ans = (ans + c(num-1,k-1))%mod;
	}
	cout<<ans<<endl;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 998244353
ll qsm(ll x,ll y){
    ll a=1;
    ll base=x;
    while(y>0){
        if(y&1){
            a=(a*base)%mod;
        }
        y>>=1;
        base=(base*base)%mod;
    }
    return a;
}
ll jc[500005]={1};
ll inv[500005]={1};
ll n,k;
void ini(){
    for(int i=1;i<=500000;i++){
        jc[i]=(jc[i-1]*i)%mod;
    }
    for(int i=1;i<=500000;i++){
        inv[i]=qsm(jc[i],mod-2);
    }
}
ll c(ll x,ll y){
    if(x>y){
        return 0;
    }
    if(x==0){
        return 1;
    }
    return jc[y]*inv[x]%mod*inv[y-x]%mod;
}
int main(){
    ini();
    cin>>n>>k;
    ll ans=0;
    for(int i=1;i<=n;i++){
        ans=(ans+c(k-1,(n-i)/i))%mod;
    }
    cout<<ans;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define ll long long
ll ksm(ll a,ll b,ll mod){ll ans=1;while(b){if(b&1)ans=(ans*a)%mod;a=(a*a)%mod;b>>=1;}return ans;}
ll gcd(ll a,ll b){return !b?a:gcd(b,a%b);}
#define pi acos(-1.0)
#define INF ~(1<<31)
#define def 500010
#define MOD 998244353
using namespace std;

ll jc[def],ny[def];

ll C(long n,long m)
{
	return jc[n]*ny[m]%MOD*ny[n-m]%MOD;
}

int main()
{	long _=1,__=1,n,k,i;
	ll ans;
	#ifndef ONLINE_JUDGE
	freopen("/Users/py/Documents/workspace/C:C++/try.in","r",stdin);
	freopen("/Users/py/Documents/workspace/C:C++/try.out","w",stdout);
	#endif
	jc[0]=ny[0]=1;
	for(i=1;i<def;i++){
		jc[i]=jc[i-1]*i%MOD;
		ny[i]=ksm(jc[i],MOD-2,MOD);
	}
	for(((0)?scanf("%ld",&_):EOF);_;_--,__++){
		scanf("%ld%ld",&n,&k);
		ans=0;
		for(i=1;n/i>=k;i++){
			ans=(ans+C(n/i-1,k-1))%MOD;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
#define pb push_back
#define F first
#define S second
#define ppp pair<ll,pair<ll,ll>>
#define pp pair<ll,ll>
#define all(x) (x).begin(),(x).end()
#define pi 3.14159265358
#define MOD 998244353

long long modPow(long long a, long long x, long long p) {
    //calculates a^x mod p in logarithmic time.
    long res = 1;
    while(x > 0) {
        if( x % 2 != 0) {
            res = (res * a) % p;
        }
        a = (a * a) % p;
        x /= 2;
    }
    return res;
}

long long modInverse(long long a, long  long p) {
    //calculates the modular multiplicative of a mod m.
    //(assuming p is prime).
    return modPow(a, p-2, p);
}
long long modBinomial(long long n, long long k, long long p) {
// calculates C(n,k) mod p (assuming p is prime).

    if(k>n)
      return 0;
    long long numerator = 1; // n * (n-1) * ... * (n-k+1)
    for (int i=0; i<k; i++) {
        numerator = (numerator * (n-i) ) % p;
    }

    long long denominator = 1; // k!
    for (int i=1; i<=k; i++) {
        denominator = (denominator * i) % p;
    }

    // numerator / denominator mod p.
    return ( numerator* modInverse(denominator,p) ) % p;
}

int main()
{

    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    freopen("error.txt", "w", stderr);
    #endif

     ios_base::sync_with_stdio(false);
     cin.tie(NULL);

     ll n,i,j,k,l;

     cin>>n>>k;

     ll ans=0;

     if(k==1)
     {
      cout<<n;
      return 0;
     }

     for(i=1;i<=n;i++)
     {
        ll tmp=n/i;
        tmp--;
        if(tmp<=0)
          continue;
        ans+=modBinomial(tmp,k-1,MOD);
        ans=ans%MOD;

     }

     cout<<ans;

}

#include<bits/stdc++.h>
#define removedups(v) sortvector(v); v.resize(unique(v.begin(),v.end()) - v.begin());
#define USE_FILE(i,o) freopen(i,"r",stdin); freopen(o,"w",stdout)
#define boost ios_base::sync_with_stdio(false); cin.tie(0)
#define readint(x) scanf("%d",&x)
#define printint(x) printf("%d",x)
#define readint64(x) scanf("%lld",&x)
#define printint64(x) printf("%lld",x)
#define printpair(p) cerr<<p.first << " " p.second <<"\n"
#define sortvector(v) sort(v.begin(),v.end())
#define trace_vector(v) for(auto x : v) cerr << x <<" ";cerr<<"\n";
using namespace std;
const int maxn = 2e5+11;
const int MAXN = 1e5+5;
const int LG = 20;
const int INF = 1e9;
using ll = long long int;
using ull = unsigned long long int;
const ll MOD2 = 998244353;
const ll MOD1 = 1e9 + 7LL;
ll *inv;
/*compute x^y*/
template<typename T>
T power(T a,T b,T mod = MOD1){
    T r = 1LL;
    while(b){
        if(b&1LL){
            r = (r * a)%mod;
        }
        a = (a * a)%mod;
        b >>= 1LL;
    }
    return r;
}
/*compute inversions*/
void inversions()
{
    inv = new ll[maxn];
    inv[0]= 0;
    for(int i = 1;i<maxn;++i){
        inv[i] = power((ll)i,MOD1-2LL);
    }
}

/*compute gcd(a,b)*/
template<typename T>
T gcd(T a,T b){
    while(b){
        T t = b % a;
        a = b;
        b = t;
    }
    return a;
}

ll fact[MAXN * 5];
void computefact(){
    fact[0] = 1;
    for(ll i = 1;i < MAXN *5;++i){
        fact[i] = (fact[i-1] * i)%MOD2;
    }
}
ll ncr(ll n,ll r){
    if(n < r) return 0;
    ll answer = fact[n];
    answer = (answer * power<ll>(fact[r],MOD2-2LL,MOD2))%MOD2;
    answer = (answer * power<ll>(fact[n-r],MOD2-2LL,MOD2))%MOD2;
    return answer;
}

ll prime[MAXN *5];
void computeSeive(int N){
    for(int i = 0;i<=N;++i) prime[i] = 0;
    prime[1] = N;
    for(int i= 2;i*i<N+1;++i){
        if(!prime[i]){
            ++prime[i];
            for(int j = 2*i;j<=N;j+=i){
                prime[j] = -1;//mark the multiples
                ++prime[i];//count the multiples
            }
        }
    }
}

ll countMultiples(ll l, ll r,ll of){
    return (r/of) - (l-1)/of;
}

int main(){
    computefact();
    int n,k;
    readint(n);
    readint(k);
    if(n < k){
        printint(0);
        return 0;
    }

    ll answer = 0;
    for(int i = 1;i<=n;++i){
        ll N = countMultiples(i+1,n,i);
        if(N>=k-1){
            answer = (answer + ncr(N,k-1))%MOD2;
        }
    }

    printint64(answer);
    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <stack>
#include <string>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <iomanip>
#include <queue>
#include <numeric>
#include <chrono>
#include <cstring>
#include <list>
#include <algorithm>
#include <sstream>
using namespace std;
const int MOD = 998244353;

long long factorial[500002];

long long fac(int n) {
    return factorial[n];
}

long long mod_exp(long long a, long long b) {
    if (b == 0) return 1;
    auto res = mod_exp(a, b / 2);
    if (b % 2) return (((res * res) % MOD) * a) % MOD;
    return (res * res) % MOD;
}

long long add(long long a, long long b) {
    a += b;
    while (a >= MOD) a -= MOD;
    while (a < 0) a += MOD;
    return a;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    long long z  = 1;
    factorial[0] = 1;
    for (int i = 1; i <= 500002; i++) {
        z *= i;
        z %= MOD;
        factorial[i] = z;
    }
//    int a = 3, b = 6, c = 9;
//    for (int i = 1; i <= a * b * c; i++) {
//        cout << i << ": " << ((i % a) % b) % c << " " << ((i % b) % a) % c
//        << ((i % a) % c) % b <<((i % c) % a) % b << ((i % c) % b) % a << ((i % b) % c) % a<< endl;
//    }
//
//    for (int i = 1; i <= a * b; i++) {
//        cout << i << " : " << ((i % a) % b) << " " << ((i % b) % a) << endl;
//    }

//    return 0;
    int n, k;
    cin >> n >> k;
    if (k > n) {
        cout << 0;
        return 0;
    }

    long long ans = 0;
    ans = fac(n - 1);
    ans = (ans * mod_exp(fac(k - 1), MOD - 2)) % MOD;
    ans = (ans * mod_exp(fac(n - k), MOD - 2)) % MOD;

    for (long long i = 2 ;i <= n; i++) {
        long long num = n / i;
        if (num < k) continue;
        long long val = 0;
        val = fac(num - 1);
        val = (val * mod_exp(fac(k - 1), MOD - 2)) % MOD;
        val = (val * mod_exp(fac(num - k), MOD - 2)) % MOD;
//        ans = (ans + val) % MOD;
        ans = add(ans, val);
    }
    cout << ans;
}

/*
 *
 *
 *
 *
9
0 0 0 1 2 4 5 6 8

 0 0 -> 1, 2
 0 4 ->  2, , 2
 */

#include  <bits/stdc++.h>

using namespace std;

#define int long long

typedef long long ll;

const int maxn = 5e5+10, mod = 998244353;

ll sum(ll x){
    return ((x*(x+1LL))/2LL)%mod;
}

typedef long long ll;

ll factorial[maxn];

ll exp(ll b, ll p){

    ll resp = 1;

    b = b % mod;

    while(p > 0){
        if(p & 1){
            resp = (resp * b)%mod;
        }
        p = p >> 1;
        b = (b * b)%mod;
    }

    return resp;
}

ll inverse(ll x){
    return exp(x, mod-2);
}

ll ncr(ll n, ll k) {
    return factorial[n] * inverse(factorial[k]) % mod * inverse(factorial[n - k]) % mod;
}

int32_t main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

    ll n, k;

    cin >> n >> k;

    if(k == 1){
        cout << n << endl;
        return 0;
    }

    factorial[0] = 1LL;

    for(ll i=1; i<=n; i++){
        factorial[i] = (factorial[i - 1] * i) % mod;
    }

    long long ans = 0LL;

    for(ll i=1; i<=k; i++){
        ll div = n/i;

        div--;

        if(div >= k-1) ans = (ans + ncr(div, k-1))%mod;
    }

    cout << ans << endl;

	return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef uint64_t bu;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<string> vs;
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define mp make_pair
#define mt make_tuple
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define rept(type, i, a, op, b, change) for (type i = a; i op b; i += change) //general for loop
#define sq(a) ll(a) * (a) //square of a number
#define nl cout << '\n'
#define o(x) cout << x; //output x
#define F first
#define S second
#define PI 3.1415926535
#define w(i,n) while(i<n)
#define s(v) sort(begin(v),end(v))
//#define M 998244353
void FAST() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}
int Rselect(vector<int>&, int, int, int); //finding the ith order statistic
int partition(vector<int>&, int, int);

template<typename T>
ostream& operator<<(ostream& stream, const vector<T>& vec) //outputting a vector
{
	for (auto& i : vec)
	{
		stream << i << ' ';
	}
	stream << '\n';
	return stream;
}

template<class T>
istream& operator>>(istream& stream, vector<T>& vec) //input for vectors of fixed size
{
	for (auto& i : vec)
	{
		stream >> i;
	}
	return stream;
}

void solve();
void scanN(vector<ll>&v,ll n)
{
    rep(i,0,n)
    {
        int num;
        cin>>num;
        v.pub(num);
    }
}
void scans(vector<string>& v,ll n)
{
    rep(i,0,n)
    {
        string s;
        cin>>s;
        v.pub(s);
    }
}
ll max(ll a,ll b)
{
    if(a>b)
    return a;
    return b;
}
ll min(ll a,ll b)
{
    if(a<b)
    return a;
    return b;
}
ll factorial(ll n)
{
    ll M = 998244353;
    if(n == 0)
    return 1;
    return n*(factorial(n-1)%M);
}
ll choose(double a,double b)
{
    ll M = 998244353;
    if(a<b)
    return 0;
    if(b == 1)
    return a;
    if(b==0)
    return 1;
    //double k = (a-b+1)/(double)b;
    //return k*(ll)choose(a,b-1);
    return (ll)(((a-b+1)/b)*(choose(a,b-1)%M));
}
int main()
{
    FAST();
   /*
	int test;
	cin >> test;
	while (test--)
	{
		solve();
	}	*/
	solve();
	return 0;
}

void solve()
{
    ll n,k;
    cin>>n>>k;
    ll M = 998244353;
    if(k>n)
    cout<<"0"<<endl;
    else if(k == 1)
    cout<<n<<endl;
    else
    {
        ll p = choose((double)n-1,(double)k-1);
        p = (ll)p;
        if(2*k>n)
        cout<<p<<endl;
        else
        {
            ll total = 0;
            ll q = n/k;
            ll i = 1;
            while(i<=n)
            {
                ll r = n/i;
                ll t = choose(r-1,k-1);
               // t = (ll)t;
               // t = t%M;
                total = total +t;
                total = total%M;
                i++;
            }
            cout<<total<<endl;
        // cout<<choose(5,5);
        }

    }
}

int Rselect(vector<int>& v, int i, int l, int r)
{
	if (l == r)
		return v[l];
	int pivot = partition(v, l, r);
	if (pivot == i)
		return v[pivot - 1];
	else if (pivot < i)
	{
		return Rselect(v, i, pivot, r);
	}
	else
	{
		return Rselect(v, i, l, pivot - 2);
	}
}

int partition(vector<int>& v, int l, int r)
{
	int pivot_index = rand() % (r - l + 1) + l;
	swap(v[pivot_index], v[l]);
	int i = l + 1, j = l + 1;
	while (j <= r)
	{
		if (v[j] < v[l])
		{
			swap(v[j], v[i]);
			i++;
		}
		j++;
	}
	swap(v[l], v[i - 1]);
	return i;
}

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define up upper_bound
#define sz(h) (int)h.size()
#define all(h) h.begin(), h.end()
#define mod 1000000007
#define mod1 998244353
#define MAX 2000010
struct hash_pair
{ // use pair as key in unordered_map<pair<int,int>,int,hash_pair>;

    template <class T1, class T2>

    size_t operator()(const pair<T1, T2> &p) const

    {

        auto hash1 = hash<T1>{}(p.first);

        auto hash2 = hash<T2>{}(p.second);

        return hash1 ^ hash2;
    }
};

int power(int x, unsigned int y = mod1 - 2, int p = mod1)
{
    int res = 1; // Initialize result

    x = x % p; // Update x if it is more than or
               // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res * x) % p;

        // y must be even now
        y = y >> 1; // y = y/2
        x = (x * x) % p;
    }
    return res % p;
}
int F[500100] = {0};

int nChoosek(int n, int k)
{
    if (k > n)
        return 0;
    if (k == 0)
        return 1;

    int res = F[n];
    res = (res * power(F[k])) % mod1;
    res = (res * power(F[n - k])) % mod1;
    return res;
}

signed main()
{
    F[0] = F[1] = 1;
    for (int i = 2; i < 50010; i++)
    {
        F[i] = (F[i - 1] * i) % mod1;
    }
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    //freopen("input.txt", "w", stdout);
#endif
    int t = 1;
    // cin >> t;
    while (t--)
    {
        int n, k;
        cin >> n >> k;

        if (k == 1)
        {
            cout << n << endl;
        }
        else
        {
            int ans = 0;
            for (int i = 1; i <= n; i++)
            {
                int x = n / i;
                if (x < k)
                    break;
                ans = (ans + nChoosek(x - 1, k - 1) % mod1) % mod1;
            }
            cout << ans << endl;
        }
    }
}

#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;

#define int long long int
#define pb push_back
#define M 1000000007
#define ff first
#define ss second
#define deb(x) cout< #x< " "< x< endl;
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(int i=k;i<=n;i++)
#define FORR(a,b,c) for(int a= b;a>=c;a--)
#define fa(arrr) for(auto x:arrr)
#define iPair pair<int, pair<int,int>>
#define sz size()
// #define mp make_pair
#define mxm3(a,b,c) max(a, max(b,c))
#define mi3(a,b,c) min(a, min(b,c))
#define mxn 500005
#define PII pair<int,int>
#define aint(v) v.begin(), v.end()
#define endl "\n"
// #define N 1000
#define C 4
#define nfs ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
// Ordered Set Tree
// typedef tree<PII, null_type, less<PII>,
//         rb_tree_tag,
//         tree_order_statistics_node_update>
//         oset;
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
	const char* comma = strchr(names + 1, ',');
	cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}

int fact[100005];

int power(int x, int y) {
	int res = 1;
	while (y) {
		if (y & 1) res = res * x % M;
		x = (x * x) % M;
		y = y / 2;
	}
	return res;
}

int modInv(int n) {
	return power(n, M - 2);
}
void facto() {
	fact[0] = 1;
	fact[1] = 1;
	for (int i = 2; i < 100005; i++)
		fact[i] = (i * fact[i - 1]) % M;
}

int fermat(int n, int r) {
	if(r>n) return 0;
	// cout << fact[1337] << endl;
	return (fact[n] * modInv(fact[r]) % M * modInv(fact[n - r]) % M) % M;
}

void solve() {
	int n, k;
	cin >> n >> k;
	facto();
	if(k==1){
		cout << n << endl;
		return;
	}
	if(k > n){
		cout << 0 << endl;
		return;
	}
	int ans = 0;
	for(int i = 1;i<=n;i++){
		// if() break;
		ans = (ans + fermat(n/i-1, k-1))%M;
	}
	cout << ans%M << endl;
}

int32_t main()
{

	nfs;
	int t;
	// facto();
	// cin >> t;
	t = 1;
	while (t--) {
		solve();
	}

	return 0;
}

#include <bits/stdc++.h>
#define lli  long long int
#define forr(i,a,n) for(i=a;i<n;i++)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define pb push_back
#define pi 3.1415926536
#define endl '\n'
#define mod 1000000007
#define mod1 998244353
#define mkp make_pair
#define N 100005
#define INF 1e18
// #define double long double
#define query cin>>q;while(q--)
#define couty cout<<"YES"<<endl
#define coutn cout<<"NO"<<endl
#define F first
#define S second

using namespace std;

lli fact(lli n){
    if(n==1 || n==0)
        return 1;
    return n*fact(n-1);
}

lli isPrime(lli n){
    if(n < 2)
        return 0;
    if(n < 4)
        return 1;
    if(n % 2 == 0 or n % 3 == 0)
        return 0;
    for(lli i = 5; i*i <= n; i += 6)
        if(n % i == 0 or n % (i+2) == 0)
            return 0;
    return 1;
}

lli modexpo(lli x,lli p){
    lli res = 1;
    x = x%mod;
    while(p){
        if(p%2)
            res = res * x;
        p >>= 1;
        x = x*x % mod;
        res %= mod;
    }
    return res;
}

lli binSearch(lli a[],lli l,lli h, lli x){
    lli c=-1;
    while(l<=h){
        lli m=(l+h)/2;
        if(a[m]>=x){
            c=m;
            h=m-1;
        }
        else l=m+1;
    }
    return c;
}

void pairsort(lli a[], lli b[], lli n){
    pair<lli, lli> pairt[n];
    for (lli i = 0; i < n; i++)
    {
        pairt[i].first = a[i];
        pairt[i].second = b[i];
    }
    sort(pairt, pairt + n);
    for (lli i = 0; i < n; i++)
    {
        a[i] = pairt[i].first;
        b[i] = pairt[i].second;
    }
}

void rev_pairsort(lli a[], lli b[], lli n){
    pair<lli, lli> pairt[n];
    for (lli i = 0; i < n; i++)
    {
        pairt[i].first = a[i];
        pairt[i].second = b[i];
    }
    sort(pairt, pairt + n);
    reverse(pairt, pairt + n);
    for (lli i = 0; i < n; i++)
    {
        a[i] = pairt[i].first;
        b[i] = pairt[i].second;
    }
}

lli nod(lli n){
    lli c=0;
    while(n>0){
        c++;
        n/=10;
    }
    return c;
}

lli sod(lli n){
    lli s=0;
    while(n>0){
        s+=n%10;
        n/=10;
    }
    return s;
}

lli mulmod(lli a, lli b, lli mod2)
{
    lli res = 0;
    a = a % mod2;
    while (b > 0)
    {
        if (b % 2 == 1)
            res = (res + a) % mod2;

        a = (a * 2) % mod2;
        b /= 2;
    }

    return res % mod;
}

string intToString(lli n){
    string s ="";
    while(n>0){
        s+=char(n%10+'0');
        n/=10;
    }
    reverse(s.begin(), s.end());
    return s;
}

int myComp(pair<lli, lli> p1, pair<lli, lli>p2){
    if(p1.second < p2.second || (p1.second == p2.second && p1.first < p2.first))
        return 1;
    return 0;
}

lli getFractionModulo(lli a, lli b, lli mod2)
{
    lli c = __gcd(a, b);

    a = a / c;
    b = b / c;

    // (b ^ m-2) % m
    lli d = modexpo(b, mod2 - 2);

    // Final answer
    lli ans = ((a % mod2) * (d % mod2)) % mod2;

    return ans;
}

lli binToNum(string s) {
    lli n = 0, i;
    forr(i,0,s.length()){
        n = 2*n + (s[i]-'0');
    }

    return n;
}

string strToBin(lli n) {
    string s = "";

    while (n > 0) {
        s += (n%2+ '0');
        n /= 2;
    }

    reverse(s.begin(), s.end());

    return s;
}

lli my_pow(lli a, lli b) {
    if (b == 0)
        return 1;
    lli x = my_pow(a, b/2);
    if (b%2)
        return a*x*x;
    else
        return x*x;
}

lli power(lli x, lli y, lli p)
{
    lli res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
lli modInverse(lli n, lli p)
{
    return power(n, p-2, p);
}

lli fac[500005];

lli nCrModPFermat(lli n, lli r, lli p)
{
   // Base case
   if (r==0)
      return 1;

    return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n-r], p) % p) % p;
}

int main(){
    IOS;
    lli n,t,p,q,r,m,k,i,j,f=0,g=0,h=1,sum=0,ans=0,l,x,y,total=0,d,minn=1e18,maxx=0,pos=0,epoch=1,cnt=0;

    cin>>n>>k;

    if (n < k){
        cout<<0;
        return 0;
    }

    if (k == n) {
        cout<<1;
        return 0;
    }

    if (k == 1) {
        cout<<n;
        return 0;
    }

    fac[0] = 1;
    for (lli i = 1; i < 500005; i++)
        fac[i] = (fac[i-1]%mod1 * i%mod1) % mod1;

    m = 0;
    forr(i, 1, k){
        if (n/i < k)
            break;
        m += nCrModPFermat(n/i-1, k-1, mod1);
        m %= mod1;
    }

    cout<<m;

    return 0;
}

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx,avx2,fma")
#include <algorithm>
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define MOD             (int)998244353
#define int             long long
#define ll              long long
#define pii             pair<int, int>
#define fi               first
#define se              second
#define sf(a)           scanf("%d", &a)
#define sfl(a)          scanf("%lld", &a)
#define pf(a)           printf("%d ", a)
#define pfl(a)          printf("%lld\n", a)
#define Case(a)         printf("Case %d: ", a)
#define FASTIO          ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define pb              emplace_back
#define mp              make_pair
#define mem(arr)        memset(arr, 0, sizeof(arr))
#define mem1(arr)       memset(arr, -1, sizeof(arr))
#define all(a)          a.begin(),a.end()
#define for0(i, n)      for (int i = 0; i < n; i++)
#define for1(i, n)      for (int i = 1; i <= n; i++)
#define forr(i,a,b)     for (int i = a; i < b; i++)
#define bforr(i,a,b)    for (int i = a ; i>=b;i--)
#define rr              return 0
#define prec(n)         fixed<<setprecision(n)
#define maxpq           priority_queue<int>
#define minpq           priority_queue<int, vector<int>, greater<int> >
#define inf             (int)(1e18)
#define vi              vector<int>
#define endl            "\n"
#define vii             vector<pii>
#define sz(s)           s.size()
#define bits(n)         __builtin_popcount(n)
#define MX              500005
#define svMX            200005

int gcd(int a, int b)   {return __gcd(a,b);}
void pr(int x)          {cout << x;}
void prl(int x)         {cout << x << endl;}

inline bool EQ(double a, double b) { return fabs(a-b) < 1e-9; }
inline bool isLeapYear(ll year) { return (year%400==0) || (year%4==0 && year%100!=0); }
inline void normal(ll &a) { a %= MOD; (a < 0) && (a += MOD); }
inline ll modMul(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a*b)%MOD; }
inline ll modAdd(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a+b)%MOD; }
inline ll modSub(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); a -= b; normal(a); return a; }
inline ll modPow(ll b, ll p) { ll r = 1; while(p) { if(p&1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }
inline ll modInverse(ll a) { return modPow(a, MOD-2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }

int p[svMX+9];
vector<ll>prime;

void sieve()
{
    int sq = sqrt(svMX);

    for(int i=3;i<=sq;i+=2){
        if(p[i] == 0){
            for(int j=i*i;j<=svMX;j+=2*i){
                p[j] = 1;
            }
        }
    }

    prime.pb(2);
    for(int i=3;i<=svMX;i+=2){
        if(p[i] == 0){
            prime.pb(i);
//            cout<<i<<" ";
        }
    }
}

const double eps = 1e-9;
const double pi = acos(-1);

int dx[5] = {+1, +0, -1, -0};
int dy[5] = {+0, +1, -0, -1};
int XX[] = { -1, -1, -1, 0, 0, 1, 1, 1 };
int YY[] = { -1, 0, 1, -1, 1, -1, 0, 1 };

bool Equal(double x, double y)
{
    return fabs(x-y)<eps; ///x==y
}

bool Greater(double x, double y)
{
    return x-eps>y; ///x>y
}

bool Lesser(double x, double y)
{
    return x+eps<y; ///x>y
}

struct point
{
    double x, y, ang;
};
#define ftmx            1000006

int ft[ftmx];
void ftupdate(int i, int add)
{
    while(i>0 && i<ftmx){
        ft[i] += add;
        i += (i&(-i));
    }
}

int ftsum(int i)
{
    int s = 0;
    while(i>0){
        s += ft[i];
        i -= (i&(-i));
    }
    return s;
}
int ftfind(int k)
{
    int curr=0, ans =0, prevsum=0;
    for(int i= 20; i>= 0;i--){
        if(curr+(1<<i)<ftmx && ft[curr+(1<<i)]+prevsum < k){
            curr += 1<<i;
            ans = curr;
            prevsum += ft[curr];
        }
    }

    return ans+1;
}

int fact[MX];

int ncr(int n, int r)
{
    int ans = 1;
    ans *= fact[n];
    return modDiv(ans, modMul(fact[r], fact[n-r]));
}

signed main()
{
    FASTIO

    fact[0] = 1;
    forr(i, 1, MX){
        fact[i] = modMul(i, fact[i-1]);
    }

    int n, k;
    cin>>n>>k;

    int ans = 0;
    forr(i, 1, n+1){
        int x = n/i - 1;
        ans = modAdd(ans, ncr(x, k-1));
    }

    cout<<ans;
}

#include<bits/stdc++.h>
using namespace std;
using ll = long long int;
const ll N = 500043;
const ll mod = 998244353;

ll fact[N];

ll add(ll x, ll y)
{
	x += y;
	while(x >= mod) x -= mod;
	while(x < 0) x += mod;
	return x;
}

ll mul(ll x, ll y)
{
	return (x * 1ll * y) % mod;
}

ll quicmod(ll x, ll y)
{
	ll z = 1;
	while(y > 0)
	{
		if(y % 2 == 1)
			z = mul(z, x);
		x = mul(x, x);
		y /= 2;
	}
	return z;
}

ll inv(ll x)
{
	return quicmod(x, mod - 2);
}

ll divide(ll x, ll y)
{
	return mul(x, inv(y));
}

void precalc()
{
	fact[0] = 1;
	for(ll i = 1; i < N; i++)
		fact[i] = mul(i, fact[i - 1]);
}

ll C(ll n, ll k)
  {
  	cout << "+ " << n << " " << k << endl;
	if(k > n) return 0;
	return divide(fact[n], mul(fact[n - k], fact[k]));
  }

int main()
{
	ll n, k;
	cin >> n >> k;
	ll ans = 0;
	precalc();

	for(ll i = 1; i <= n; i++)
	{
		ll d = n / i;
		ans = add(ans, C(d - 1, k - 1));
	}
	cout << ans << endl;
}

#include <bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define pii pair<int,int>
#define int long long
const int inf = 0x3f3f3f3f;
const int maxn = 501110;
const int M = 1e9+7;
int n,m,k,ok;

int inv[maxn];

void init()
{
    inv[1] = 1;
    for(int i = 2; i < maxn; i++)
    {
        inv[i] = (M-M/i)*inv[M%i]%M;
    }
}

int c(int x,int y)          //c(5,2)
{
    if(y > x) return 0;
    int res = 1;
    y = min(y,x-y);
    for(int i = 1; i <= y; i++)
    {
        res = (res*(x-i+1)%M*inv[i])%M;
    }
    return res;
}

signed main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("data.in", "r", stdin);
#endif
    init();
    cin>>n>>k;
    int ans = 0;
    for(int i = 1; i < n; i++)
    {
        int res = n/i; res--;
        ans += c(res,k-1);
    }
    cout<<ans<<endl;
    return 0;
}

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LETS_GET_SCHWIFTY ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ff              first
#define ss              second
#define int             long long
#define ll              long long
#define ld              long  double
#define pb              push_back
#define pii             pair<int,int>
#define vi              vector<int>
#define mii             map<int,int>
#define pqb             priority_queue<int>
#define pqs             priority_queue<int,vi,greater<int> >
#define setbits(x)      __builtin_popcountll(x)
#define zerobits(x)      __builtin_ctzll(x)
#define mod             998244353
#define Mod             1000000007
#define inf             1e18
#define ps(x,y)         fixed<<setprecision(y)<<x
#define vpii            vector<pair<int,int> >
#define all(x)          x.begin(),x.end()
#define matrixprint(arr,a,b,c,d) for(int i=a;i<=c;i++){for(int j=b;j<=d;j++){cout<<arr[i][j]<<" ";}cout<<"\n";}
#define show(arr,x,y)   for(int i=x;i<=y;i++){cout<<arr[i]<<" ";}cout<<"\n"
#define inc(i,x,y)      for(int i=x;i<y;i++)
#define dec(i,x,y)      for(int i=x;i>=y;i--)

const int N = 2e5 + 5;

#define TRACE
#ifdef TRACE
#define deb(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
    cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define deb(...)
#endif

//////////////////////////////code//////////////////////////////
int a,b,t;

int fac[200001];
int inv[200001];

int power(int a, int n = mod - 2)
{
	if (!n)
		return 1;
	int pt = power(a, n / 2);
	pt *= pt, pt %= mod;
	if (n & 1)
		pt *= a, pt %= mod;
	return pt;
}

int ncr(int n, int r)
{
	int ans1 = fac[n];
	int ans2 = (inv[r] * inv[n - r]) % mod;

	ans1 = (ans1 * ans2) % mod;

	return ans1;
}

void fillfac()
{
    fac[0] = inv[0] = 1;

	for (int i = 1; i <=200001; ++i)
	{
		fac[i] = (fac[i - 1] * i) % mod;
		inv[i] = power(fac[i]);
	}

}

void solve()
{
   // cout << "-------------------" << "\n";

 int n,k;cin>>n>>k;

 fillfac();

 int ans = 0;

 if(n<k)
 {
     cout<<0<<"\n";

 }
 else if(k==1)
 {
     cout<<n<<"\n";
 }
 else
 {

 for(int i=1;i<=n;i++)
 {
     if(n/i-1 >=k-1)
     ans += ncr((n/i) -1,k-1);
     ans%=mod;
 }

 }

 cout<<ans<<"\n";

   // cout << "-------------------" << "\n";

}

int32_t main()
{

    LETS_GET_SCHWIFTY;

    int t = 1;
   // cin >> t;

    while (t--)
        solve();

}

#include <bits/stdc++.h>
using namespace std;
long long ll,tt,i,j,b[1212145],c[1111456],d;
long long x,m,n,r,s,t,k,l,y,z;
string p,q ;
long long a[1234567];
vector<int> h,hh;
int main()
{
    cin >> n;
    for (i = 0; i <n; i ++)
        cin >> a[i];
    s = 0;
    for (z=1;z<=30; z++){
        x=-100;
        m=0;
        for (i = 0; i <n; i ++){
            if (a[i]>m+a[i]){
                m=a[i];
                x=a[i];
            }
            else {
                   m += a[i];
                   x=max(x,a[i]);
                }
            if (x > z){
                m=0;
                x=0;
            }
                s=max(s,m-x);
            }

        }
        cout <<s<<endl;
        return 0;
    }

#include <bits/stdc++.h>
#define R register int
#define ll long long
using namespace std;
const ll P=998244353;
const int maxn=1e7+10;
ll frac[maxn];
void init()
{
	frac[0]=1;
	for(R i=1;i<=maxn;i++)frac[i]=frac[i-1]*i%P;
}
ll ksm(ll a,ll b)
{
	ll ans=1;
	a%=P;
	while(b)
	{
		if(b&1)ans=(ans*a)%P;
		b>>=1;
		a=(a*a)%P;
	}
	return ans;
}
ll inv(ll a)
{
	return ksm(a,P-2);
}
ll C(int n,int m)
{
    if(m>n)return 0;
    return frac[n]*inv(frac[m]*frac[n-m]%P);
}
int main()
{
	int t;
	scanf("%d",&t);
	init();
	while(t--)
	{
		int n,m;
		ll ans=0;
		scanf("%d%d",&n,&m);
		for(R i=1;i<n;i++)
		{
			int x=(n-1)/i-1,y=m-1;
			ans=(ans+C(x,y))%P;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define mem(a, x) memset(a, x, sizeof(a))
#define IOS std::ios::sync_with_stdio(false)
#define FRE freopen("in.txt", "r", stdin);
#define ls o<<1
#define rs o<<1|1
#define test(a) cout<<a<<endl;
#define exp 0.000001
#define pb push_back
typedef long long ll;
const int mod = 998244353;
const int maxn = 5e5 + 5;
const int inf = 0x3f3f3f3f;

ll pre[maxn];
ll qpow(ll a,ll b)
{
	if(b==0)
		return 1;
	ll temp=qpow(a,b/2);
	ll ans=temp*temp%mod;
	if(b&1)
		ans=ans*a%mod;
	return ans;
}
ll cal(ll m,ll n)
{
   if(m<n)
   	return 0;
   ll ans=pre[m]*qpow(pre[m-n],mod-2)%mod;
   ans=ans*qpow(pre[n],mod-2)%mod;
   return ans;
}
void solve()
{
   ll n,k;
   pre[0]=1;
   for(int i=1;i<=500000;i++)
   	pre[i]=pre[i-1]*i%mod;
   scanf("%lld%lld",&n,&k);
   if(k>n)
   	printf("0\n");
   else if(k==1)
   	printf("%lld\n",n);
   else {
       ll ans=(cal(n-1,k-1)+cal(n/2-1,k-1))%mod;
       printf("%lld\n",ans);
   }
}
int main()
{
	//int t;scanf("%d",&t);while(t--)
	solve();
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int xGCD(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }

    int x1, y1, gcd = xGCD(b, a % b, x1, y1);
    x = y1;
    y = x1 - (long long)(a / b) * y1;
    return gcd;
}

// factorial of n modulo MOD
int modfact(int n) {
    int result = 1;
    while (n > 1) {
        result = (long long)result * n % MOD;
        n -= 1;
    }
    return result;
}

// multiply a and b modulo MOD
int modmult(int a, int b) {
    return (long long)a * b % MOD;
}

// inverse of a modulo MOD
int inverse(int a) {
    int x, y;
    xGCD(a, MOD, x, y);
    return x;
}

// binomial coefficient nCk modulo MOD
int NCR(int n, int k)
{
    return modmult(modmult(modfact(n), inverse(modfact(k))), inverse(modfact(n - k)));
}
void solve(){
	int n, k ;
	cin>>n>>k;
	if(k>n){
		cout<<0;
		return;
	}
	if(k==1){
		cout<<n;
		return;
	}
	if(n/k==1){
		cout<<NCR(n-1,n-k)%MOD;
		return;
	}
	int ans = NCR(n-1,k-1)%MOD;
	int i = 2;
	while (n/i>=k){
		ans+=NCR(n/i-1, k-1);
		ans%=MOD;
		i++;
	}
	if(ans<=0) ans+=MOD;
	cout<<ans;

}
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

#include <bits/stdc++.h>
#define int long long int
#define ii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
using namespace std;
#define MOD 1000000007
#define output(x) for (auto a:x) cout<<a<<" ";cout<<endl;
#define output2(x) for (auto a:x) cout<<a.fi<<" "<<a.se<<endl;
#define PI 3.14159265

// DEBUG TEMPLATE
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
	*this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

// DEBUG TEMPLATE ENDS

int power(int x,int y,int mod = MOD)
{
 	int ret = 1;
 	x = x % mod;
 	while (y){
 		if(y&1) ret = (ret*x)%mod;
 		y = y>>1;
 		x = (x*x)%mod;
    }
    return ret%mod;
}

int curbest(int d,int x){

}

void solve()
{
	int th,tc,x;
	cin>>th>>tc>>x;
	int low = 0;
	int high = 1e12;
	auto val = [&] (int mid){
		long double ret = 1;
		ret = (long double) (mid*(tc+th) - tc) / (2*mid - 1);
		return abs(x-ret);
	};
	long double eqdiff = (long double) x - (long double)(tc+th)/2;
	if (2*x == tc+th){
		cout<<2<<endl;
		return;
	}
	if (x == th){
		cout<<1<<endl;
		return;
	}
	while (low+1<high){
		int mid = (high-low+1)/2 + low;
		if (val(mid) <= val(mid+1)) {
			high = mid;
		} else low = mid;
		if (mid == (high-low+1)/2 + low) break;
	}
	low++;
	long double bd = val(low);
	int turn = 2*low-1;
	int lturn = turn;
	for (int i = max(1ll,lturn - 1000) ; i < lturn + 1000; i +=2){
		if (val(i/2) < bd){
			bd = val(i);
			turn = i;
		}
	}
	if (bd < eqdiff){
		cout<<turn<<endl;
	} else {
		cout<<2<<endl;
	}
}

signed main(){
	int t;
	cin>>t;
	while (t--)
	solve();
}

/*
	  Author : @evenbao
	  Created :
*/

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;

#define pii pair<int , int>
#define mp make_pair
#define fi first
#define se second

template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void read(T &x) {
    T f = 1; x = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
    x *= f;
}

const int N = 5e5 + 10;
const int mod = 998244353;

int n , k;
int fac[N] , ifac[N];

inline int quickpow(int a , int n) {
		int res = 1;
		for (; n; n >>= 1 , a = (LL) a * a % mod)
				if (n & 1) res = (LL) res * a % mod;
		return res;
}
inline void init(int n) {
		fac[0] = 1;
		for (int i = 1; i <= n; ++i) fac[i] = (LL) fac[i - 1] * i % mod;
		ifac[n] = quickpow(fac[n] , mod - 2);
		for (int i = n - 1; i >= 0; --i) ifac[i] = (LL) ifac[i + 1] * (i + 1) % mod;
}
inline int binom(int n , int m) {
		if (n < m) return 0;
		else if (m == 0) return 1;
		else return (LL) fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
inline void inc(int &x , int y) {
		x = x + y < mod ? x + y : x + y - mod;
}
inline void dec(int &x , int y) {
		x = x - y >= 0 ? x - y : x - y + mod;
}

int main() {

		read(n); read(k); init(1e5);
		int ans = 0;
		for (int i = 1; i <= n; ++i) inc(ans , binom((n - i) / i , k - 1));
		printf("%d\n" , ans);
	  return 0;
}

#include <bits/stdc++.h>

#define int int64_t
#define pb push_back
#define Start_time clock_t startTime = clock();
#define End_time clock_t endTime = clock(),clockTicksTaken = endTime - startTime;double t = clockTicksTaken / (double) CLOCKS_PER_SEC;cout<<sp(t)<<endl;
#define ibswsct() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define gcd __gcd
#define s second
#define f first
#define sp(x) setprecision(13) << fixed << x

using namespace std;

typedef pair<int,int> pii ;
typedef pair<pair<int,int>,int> pii_i ;
typedef pair<int,pair<int,int> > pi_ii ;
typedef pair<pair<int,int>,pair<int,int> > piiii ;
// for order_of_key():
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>  ordered_set;

const int N = 5e5 + 10, mod = 998244353;
int n, k, fac[N];

int power(int x, int y = mod - 2){
    if(y == 0){
        return 1;
    }
    int ret = power(x, y >> 1);
    if(y & 1){
        return (((ret * ret) % mod) * x) % mod;
    }
    return (ret * ret) % mod;
}

int en(int x, int y){
    if(y < x){
        return 0;
    }
    if(x == 0){
        return 1;
    }
    int ret2 = (power(fac[x]) * power(fac[y - x])) % mod;
    ret2 *= fac[y];
    ret2 %= mod;
    return ret2;
}

int32_t main(){
	ibswsct();
	cin >> n >> k;
	if(k == 1){
        cout << n;
        return 0;
	}
	fac[0] = 1;
	for(int i=1;i<=5e5;i++){
        fac[i] = (fac[i - 1] * i) % mod;
	}
	int ans = 0;
	ans = en(k - 1, n / 2 - 1) + en(k - 1, n - 1);
	cout << ans;
}

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
const ll MOD = 998244353;

ll binpow(ll a, ll n) {
    ll r = 1;
    while (n) {
        if (n % 2 == 0) {
            a = (a * a) % MOD;
            n /= 2;
        } else {
            r = (r * a) % MOD;
            --n;
        }
    }
    return r;
}

ll inv(ll a) {
    return binpow(a, MOD - 2);
}

void solve() {
    ll n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n << endl;
        return;
    }
    if (n < k) {
        cout << 0 << endl;
        return;
    }
    vector<ll> fact(n + 1);
    fact[0] = 1;
    for (ll i = 1; i <= n; ++i) {
        fact[i] = (fact[i - 1] * i) % MOD;
    }
    auto combinations = [&](ll n, ll k) {
        ll r = (((fact[n] * inv(fact[k])) % MOD) * inv(fact[n - k])) % MOD;
        //cout << "combinations(" << n << ", " << k << ") = " << r << endl;
        return r;
    };
    ll ans = 0;
    for (ll mn = 1; mn <= n - k; ++mn) {
        if ((n - mn) / mn >= k - 1) {
            ans += combinations((n - mn) / mn, k - 1);
            ans %= MOD;
        }
    }
    cout << ans << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    solve();

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e7+5,p=998244353;

long long inv[maxn],inf[maxn],fac[maxn];

inline long long C(int n,int m){
	if(n<m) return 0;
    return fac[n]*inf[m]%p*inf[n-m]%p;
}

void init(int n){
    inf[0]=inf[1]=inv[1]=fac[0]=fac[1]=1;
    for(int i=2;i<=n;i++){
	    inv[i]=inv[p%i]*(p-p/i)%p;
	    fac[i]=fac[i-1]*i%p;
	    inf[i]=inf[i-1]*inv[i]%p;
	}
}

int main(){
	int t=1;
	init(1e5);
    while(t--){
    	int n,m;
	    scanf("%d%d",&n,&m);
	    int ans=0;
		for(int i=1;i<=n;i++){
		    ans+=C((n)/i-1,m-1);
		    ans-=ans>=p?p:0;
		}
		printf("%d\n",ans);
	}
	return 0;
}

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
int main()
{
   return 0;
}

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;

#define ld              long double
#define mod             1000000007
#define ff              first
#define ss              second
#define int             long long
#define pb              push_back
#define mp              make_pair
#define pii             pair<int,int>
#define vpii            vector<pair<int,int>>
#define fr(i,a,b)     for(int i = a; i < b; i += 1)
#define all(x)          x.begin(),x.end()
#define sz(a)           (int)(a.size())
#define vi              vector<int>
#define mii             map<int,int>
#define pqb             priority_queue<int>
#define pqs             priority_queue<int,vi,greater<int> >
#define setbits(x)      __builtin_popcountll(x)
#define zrobits(x)      __builtin_ctzll(x)
#define inf             1e18
#define ps(x,y)         fixed<<setprecision(y)<<x
#define mk(arr,n,type)  type *arr=new type[n];
#define w(x)            int x; cin>>x; while(x--)
#define pw(b,p)         pow(b,p) + 0.1
#define input(a)      for(auto it = a.begin(); it != a.end(); it++) { int value; cin >> value; *it = value;}
#define print(a)        for(auto it = a.begin() ; it != a.end() ; it++){ cout << *it << " " ;}cout << '\n';
mt19937                 rng(chrono::steady_clock::now().time_since_epoch().count());

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;

#define SS                      stringstream
#define db(...)                 __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cerr << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ',');
    cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
void FASTIO()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}

#define MAXN   100001
// stores smallest prime factor for every number
int spf[MAXN];
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
void sieve()
{
    spf[1] = 1;
    for (int i = 2; i < MAXN; i++)

        // marking smallest prime factor for every
        // number to be itself.
        spf[i] = i;

    // separately marking spf for every even
    // number as 2
    for (int i = 4; i < MAXN; i += 2)
        spf[i] = 2;

    for (int i = 3; i * i < MAXN; i++)
    {
        // checking if i is prime
        if (spf[i] == i)
        {
            // marking SPF for all numbers divisible by i
            for (int j = i * i; j < MAXN; j += i)

                // marking spf[j] if it is not
                // previously marked
                if (spf[j] == j)
                    spf[j] = i;
        }
    }
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
vector<int> getFactorization(int x)
{
    vector<int> ret;
    while (x > 1)
    {
        ret.push_back(spf[x]);
        x = x / spf[x];
    }
    return ret;
}
#define ll long long

ll dp(int n, int r, ll p)
{
    ll memo[r + 1];
    memset(memo, 0,sizeof(memo));

    memo[0] = 1;

    for (int i = 1; i <= n; i++)
    {
        for (int j = min(i, r); j > 0; j--)
        {
            memo[j] = (memo[j] + memo[j - 1]) % p ;
        }
    }
    return memo[r];
}

ll C(ll n, ll r, ll p)             // p is small prime
{
    if (r == 0)
    {
        return 1;
    }
    if (r > n)      //degenerate case
    {
        return 0;
    }

    int nd = n % p;
    int rd = r % p;

    return ( C(n / p, r / p, p) * dp(nd, rd, p) ) % p;

}

#define mm 998244353
const int mxm = 5e5;
signed main()
{
    FASTIO();
    int fac[mxm+5];
    fac[0] = 1;
    fac[1] = 1;
    fac[2] = 2;
    for(int i = 3;i<=(mxm+2);i++)
    {
        fac[i] = (i*fac[i-1])%mm;
    }
    //w(x)
    {
        int n, k;
        cin >> n >> k;
        int ans = 0;
        fr(i, 1, n + 1)
        {
            int d = (n / i);
            if ((d - 1) < (k - 1)) break;
            int chk = fac[d-1];
            int d1 = fac[k-1];
            int d2 = fac[d-k];
            int dd = (d1*d2);
            int up = chk/dd;
            up%=mm;
            ans+=up;
            ans%=mm;
        }
        cout << ans%mm << "\n";
    }
    return 0;
}

// #pragma GCC target   ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
// #pragma GCC optimize ("Ofast,no-stack-protector")
// #pragma GCC optimize ("unroll-loops")
// #pragma GCC optimize ("fast-math")
// #pragma comment(linker, "/stack:200000000")

#include<bits/stdc++.h>
using namespace std;

typedef long long int      ll;
typedef long double        ld;
typedef unsigned long long ull;
typedef vector<ll>         vl;
typedef vector<vl>         vvl;
typedef pair<ll,ll>        pll;
typedef vector<pll>        vpll;

#define ff          first
#define ss          second
#define pb          push_back
#define mp          make_pair
#define eb          emplace_back
#define fr(i,n)     for(ll i = 0; i < n; ++i)
#define frs(i,s,n)  for(ll i = s; i < n; ++i)
#define frb(i,s,e)  for(ll i = s; i <= e; ++i)
#define rfr(i,n)    for(ll i = n-1; i >= 0; i--)
#define frbr(i,e,s) for(ll i = e; i >= s; i--)
#define all(x)      (x).begin(), (x).end()
#define sz(x)       ((ll)(x).size())

inline void __print(int x) {cerr << x;}
inline void __print(long x) {cerr << x;}
inline void __print(long long x) {cerr << x;}
inline void __print(unsigned x) {cerr << x;}
inline void __print(unsigned long x) {cerr << x;}
inline void __print(unsigned long long x) {cerr << x;}
inline void __print(float x) {cerr << x;}
inline void __print(double x) {cerr << x;}
inline void __print(long double x) {cerr << x;}
inline void __print(char x) {cerr << '\'' << x << '\'';}
inline void __print(const char *x) {cerr << '\"' << x << '\"';}
inline void __print(const string &x) {cerr << '\"' << x << '\"';}
inline void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V>
inline void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
inline void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
inline void _print() {cerr << "]\n";}
template <typename T, typename... V>
inline void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}

clock_t startTime;
inline double getCurrentTime() {return ((double)(clock() - startTime)) / CLOCKS_PER_SEC;}

#ifdef LOCAL
#define dbg(x...)      cerr << "[" << #x << "] = ["; _print(x)
#define dbg_arr(a,n)   cerr << "[" << #a << "] = [ ";fr(i,n)cerr<<a[i]<<" ";cerr<<"]\n";
#define dbg_mat(m,r,c) cerr<<"[" <<#m<<"]:\n";fr(i,r){cerr<<"[ ";fr(j,c)cerr<<m[i][j]<<" ";cerr<<"]\n";}
#define dbg_time()     cerr<<endl<<"Time elapsed: "<<getCurrentTime()<<endl<<endl<<endl;
#else
#define dbg(x...)      {}
#define dbg_arr(a,n)   {}
#define dbg_mat(m,r,c) {}
#define dbg_time()     {}
#endif

const ld PI   = 3.141592653589793;
const ld EPS  = 1e-9;
const ll MOD  = 1e9+7; // 998244353;
const ll INF  = 1e18;
const ll SINF = 1e9;
const ll MAX  = 500500;

inline ll mop(ll a, ll b)
{
  return (a - (a / b) * b);
}

inline ll add(ll a, ll b)
{
  return mop(((mop(a, MOD)) + (mop(b, MOD))), MOD);
}

inline ll mul(ll a, ll b)
{
  return mop(((mop(a, MOD)) * (mop(b, MOD))), MOD);
}

inline ll sub(ll a, ll b)
{
  a = mop(a, MOD);
  b = mop(b, MOD);
  a -= b;
  if (a < 0) a += MOD;
  return a;
}

inline ll mpow(ll a, ll b)
{
  a = mop(a, MOD);
  ll res = 1;
  while (b > 0)
  {
    if (b & 1)
      res = mul(res, a);
    a = mul(a, a);
    b >>= 1;
  }
  return res;
}

inline ll npow(ll a, ll b)
{
    ll res = 1;
    while (b > 0)
    {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}

inline ll inv(ll a)
{
  return mpow(a, MOD - 2);
}

ll factorial[MAX];
ll inv_factorial[MAX];

void prepare_factorials()
{
  factorial[0] = 1;
  frs(i, 1, MAX)
    factorial[i] = mul(factorial[i-1], i);
  inv_factorial[0] = 1;
  inv_factorial[1] = 1;
  frs(i, 2, MAX)
    inv_factorial[i] = sub(MOD, mul(MOD / i, inv_factorial[mop(MOD, i)]));
  frs(i, 1, MAX)
    inv_factorial[i] = mul(inv_factorial[i], inv_factorial[i-1]);
}

ll ncr(ll n, ll r)
{
  if(n < 0 || r < 0 || r > n)
    return 0;
  else
    return mul(factorial[n], mul(inv_factorial[n - r], inv_factorial[r]));
}

void pre()
{
  prepare_factorials();
}

void solve()
{
  ll n, k;
  cin >> n >> k;
  if(k > n)
    cout << "0" << "\n";
  else
  {
    ll ans = 0;
    frb(i, 1, n)
    {
      ans = add(ans, ncr(n / i - 1, k - 1));
    }
    cout << ans << "\n";
  }
}

signed main()
{
    startTime = clock();

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    //cout << fixed << setprecision(15);
    pre();

    ll test = 1;
    // cin >> test;
    frb(_CASE_, 1, test)
    {
      // cout << "Case #" << _CASE_ << ": ";
      //dbg(_CASE_);
      solve();
    }

    dbg_time();

    return 0;
}

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#define ll long long
#define F(i,a,b) for(int i=(a);i<=(b);i++)
#define mst(a,b) memset((a),(b),sizeof(a))
#define PII pair<int,int>
#define rep(i,x,y) for(auto i=(x);i<=(y);++i)
#define dep(i,x,y) for(auto i=(x);i>=(y);--i)
using namespace std;
template<class T>inline void rd(T &x) {
    x=0; int ch=getchar(),f=0;
    while(ch<'0'||ch>'9'){if (ch=='-') f=1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    if(f)x=-x;
}
const int inf=0x3f3f3f3f;
const int maxn=500050;
const ll p=998244353;
ll n,k,fac[maxn];
ll ksm(ll a,ll b)
{
    ll res=1%p;
    while(b)
    {
        if(b&1) res=(res*a)%p;
        a=(a*a)%p;
        b>>=1;
    }
    return res;
}
ll c(ll n,ll m)
{
    return ((fac[n]%p*ksm(fac[m],p-2)%p)*ksm(fac[n-m],p-2)%p)%p;
}
int main()
{
    cin>>n>>k;
    if(k>n) puts("0");
    else if(k==n) puts("1");
    else
    {
        fac[0]=fac[1]=1;
        for(int i=1;i<=n;i++) fac[i]=(fac[i-1]*i)%p;
        ll ans=c(n-1,k-1)%p;
        ans=(ans+c(n/2,k))%p;
        if(n%2==0) ans=(ans+c(n/2,k)-1)%p;
        cout<<ans<<endl;
    }

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <deque>
#include <bits/stdc++.h>
//#include "testlib.h"
using namespace std;
#define ll long long
#define pii pair<int,int>
#define qi ios::sync_with_stdio(0)

bool debug=true;

/*    *************************************
	  * Written in New Computer           *
	  * The following code belongs to     *
	  * XiaoGeNintendo of HellHoleStudios *
	  *************************************
*/
template<typename T1,typename T2>ostream& operator<<(ostream& os,pair<T1,T2> ptt){
	os<<ptt.first<<","<<ptt.second;
	return os;
}
template<typename T>ostream& operator<<(ostream& os,vector<T> vt){
	os<<"{";
	for(int i=0;i<vt.size();i++){
		os<<vt[i]<<" ";
	}
	os<<"}";
	return os;
}

int n,k;

ll fact[500005];
ll inv[500005];
const ll mod=998244353;

ll qp(ll a,ll b){
	if(b==0){
		return 1;
	}
	ll ans=qp(a,b/2);
	if(b%2){
		return ans*ans%mod*a%mod;
	}else{
		return ans*ans%mod;
	}
}

inline ll C(ll n,ll k){
	if(n-k<0){
		return 0;
	}
	return fact[n]*inv[k]%mod*inv[n-k]%mod;
}

int main(int argc,char* argv[]){
	cin>>n>>k;

	fact[0]=1;
	for(int i=1;i<=n;i++){
		fact[i]=fact[i-1]*i%mod;
	}

	for(int i=0;i<=n;i++){
		inv[i]=qp(fact[i],mod-2);
//		cout<<inv[i]<<" "<<factendl;
	}

	ll ans=0;
	for(int i=1;i<=n;i++){
		cout<<n/i-1<<" "<<k-1<<" "<<C(n/i-1,k-1)<<endl;
		ans+=C(n/i-1,k-1);
		ans%=mod;
	}

	cout<<ans<<endl;
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int,int> PII;
typedef pair<ll,int> Pli;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
//typedef pair<ll,ll>P;
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
#define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
#define REP(i,n) for(int i=0;i<n;++i)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define fors(i) for(auto i:e[x]) if(i!=p)
#define ls p<<1
#define rs p<<1|1

const int N=1222222,M=12222222;
      ll MOD=998244353;
      int intINF=int(1e9);
      ll llINF=ll(2e18);
      db eps=1e-8;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};
      long double pi=acos(-1.0L);
      ld s2=sqrt(2.0);

int read()
{
   int v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

ll readll()
{
   ll v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

inline char nc()
{
    static char buf[100000],*p1,*p2;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

int rd()
{
    int x=0; char ch=nc();
    while(ch<'0'||ch>'9') ch=nc();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=nc();
    return x;
}

/*ll pw(ll x,ll y)
{
    ll res=1;
    while(y)
    {
        if(y&1) res=res*x%MOD;
        x=x*x%MOD;
        y>>=1;
    }
    return res;
}

void pr128(__int128 x)
{
	if(x<0) putchar('-'),x=-x;
	if(x<10) return putchar('0'+x),void();
	pr128(x/10),putchar('0'+(x%10));
}*/

ll fac[N],inv[N];

void predo()
{
    fac[0]=1;
    rep(i,1,1111111) fac[i]=fac[i-1]*i%MOD;
    inv[0]=inv[1]=1;
    rep(i,2,1111111) inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
    rep(i,1,1111111) inv[i]=inv[i-1]*inv[i]%MOD;
}

ll C(ll x,ll y)
{
    return fac[x]*inv[y]%MOD*inv[x-y]%MOD;
}

int n,k;

void init()
{
    n=read(),k=read();
    if(n<k)
    {
        printf("0\n");
        return;
    }
    ll ans=0;
    rep(fi,1,k)
    {
        int tot=n/fi;
        ans=(ans+C(tot-1,k-1))%MOD;
        //printf("C(%d,%d)\n",tot-1,k-1);
    }
    printf("%I64d\n",ans);
}

void solve()
{
}

int main()
{
    //freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
    //int cas=read();
    predo();
    //while(cas--)
    //{
        init();
        solve();
    //}
    return 0;
}

#include "bits/stdc++.h"
using namespace std;

template <class T>
bool uin(T& a, T b) { return a > b ? (a = b, true) : false; }
template <class T>
bool uax(T& a, T b) { return a < b ? (a = b, true) : false; }

const long long MOD = 998244353;
const int nax = 5e5 + 10;
long long f[nax], inv[nax];

long long pow(long long a, long long b = MOD - 2LL) {
	long long res = 1;
	while (b) {
		if (b & 1) res = res * a % MOD;
		a = a * a % MOD;
		b >>= 1;
	}
	return res;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	f[0] = 1;
	for (int i = 1; i < nax; ++i) {
		f[i] = f[i - 1] * i % MOD;
		inv[i] = pow(f[i]);
	}

	int n, k;
	cin >> n >> k;
	long long ans = 0;
	for (int i = 1; i <= n; ++i) {
		long long z = n / i;
		if (z >= k)
			ans = (ans + f[z - 1] * inv[k - 1] % MOD * inv[z - k] % MOD) % MOD;
	}
	cout << ans << '\n';
}

#include <bits/stdc++.h>
using namespace std;

const int mod = 998244353;

typedef long long ll;

#define N 1500

ll C[N][N];

void init() {
	C[1][0] = 1; C[1][1] = 1;
	for (int i = 2; i < N; i++) {
		C[i][0] = C[i][i] = 1;
		for (int j = 1; j < i; j++) {
			C[i][j] = C[i-1][j] + C[i-1][j-1];
			C[i][j] %= mod;
		}
	}
}

int main() {
	ll n, k;
	cin >> n >> k;
	init();

	int res = C[n-1][k-1];
	for (int i = 2; i < 1337; i++) {
		int x = n/i;
		if (x < k) break;
		res += C[x-1][k-1];
		res %= mod;
	}
	cout << res << endl;
}

#include <bits/stdc++.h>
using namespace std;

const double pi = acos(-1.0);
typedef long long ll;

ll n, k;

const int MOD = 998244353;
const int N = 5e5 + 5;

int f[N], inv[N], finv[N];
// inv[]: inverse element

int powMod(int u, int v) {
    int res = 1;
    while (v) {
        if (v & 1) res = (ll)res * u % MOD;
        v >>= 1;
        u = (ll) u * u % MOD;
    }
    return res;
}

void initInv() {
    f[0] = 1;
    for (int i = 1; i < N; i++) {
        f[i] = (ll)f[i - 1] * i % MOD;
    }
    inv[0] = inv[1] = 1;
    for (int i = 2; i < N; i++) {
        inv[i] = (ll)(MOD - MOD / i) * inv[MOD % i] % MOD;
    }
    finv[0] = finv[1] = 1;
    for (int i = 2; i < N; i++) {
        finv[i] = ((ll)finv[i - 1] * inv[i]) % MOD;
    }
}

int C(int x, int y) {
    if (y < 0) return 0;
    return ((ll)f[x] * finv[y] % MOD) * finv[x - y] % MOD;
}

int Lucas(int u, int v) {
    if (v == 0) return 1;
    return (ll)C(u % MOD, v % MOD) * Lucas(u / MOD, v / MOD) % MOD;
}

int main() {
    ios::sync_with_stdio(false);
    initInv();
    cin >> n >> k;
    if (n < k) cout << 0 << endl;
    else {
        ll ans = C(n - 1, k - 1);
        if (n - 1 < k - 1) ans = 0;
        if (n / 2 >= k) ans = (ans + C(n / 2, k)) % MOD;
        cout << ans << endl;
    }
    return 0;
}

//#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <map>
#include <cmath>
#include <iomanip>
#include <fstream>

using namespace std;

#define int long long
const int MX = 1e7;
int mod = 998244353;
int fast (int a, int n) {
    if (n == 0)
        return 1;
    if (n % 2 == 1)
        return (fast(a, n-1) * a)%mod;
    else {
        int b = fast(a, n/2);
        return (b * b) % mod;
    }
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n;
        exit(0);
    }
    int ans = 0;

    vector<int> two(MX, 1);
    for (int i = 1; i < MX; ++i) {
        two[i] = two[i - 1] * i;
        two[i] %= mod;
    }
    for (int i = 1; i <= n; ++i) {
        int cnt = n / i;
        if (cnt >= k) {
            cnt--;
            ans += two[cnt];
            ans %= mod;
            ans *= fast(two[k - 1], two[k - 1] - 1);ans %= mod;
            ans *= fast(two[cnt - k + 1], two[cnt - k + 1] - 1);
            ans %= mod;
        }
    }
    cout << ans;
}

//#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <map>
#include <cmath>
#include <iomanip>
#include <fstream>

using namespace std;

#define int long long
const int MX = 1e7;
int mod = 998244353;
int fast (int a, int n) {
    if (n == 0)
        return 1;
    if (n % 2 == 1)
        return (fast(a, n-1) * a)%mod;
    else {
        int b = fast(a, n/2);
        return (b * b) % mod;
    }
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n;
        exit(0);
    }
    int ans = 0;

    vector<int> two(MX, 1);
    for (int i = 1; i < MX; ++i) {
        two[i] = two[i - 1] * i;
        two[i] %= mod;
    }
    for (int i = 1; i <= n; ++i) {
        int cnt = n / i;
        if (cnt >= k) {
            cnt--;
            ans += two[cnt];
            ans %= mod;
            ans *= fast(two[k - 1], two[k - 2]);ans %= mod;
            ans *= fast(two[cnt - k + 1], two[cnt - k + 1] - 2);
            ans %= mod;
        }
    }
    cout << ans;
}

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define mod 998244353
int product[500001];
int modinverse(int a, int m)
{
    int m0 = m;
    int y = 0, x = 1;
    if (m == 1)
      return 0;
    while (a > 1)
    {
        int q = a / m;
        int t = m;
        m = a % m, a = t;
        t = y;
        y = x - q * y;
        x = t;
    }
    if (x < 0)
       x += m0;
    return x%mod;
}
int ncr(int n,int r)
{
    if(n<r || n<0 || r<0)
    return 0;
    int numerator,denominator;
    numerator = product[n];
    denominator = (product[r]*product[n-r])%mod;
    int ans=(numerator*modinverse(denominator,mod))%mod;
    return ans;
}
signed main()
{
    int n,k,i,ans=0;
    cin>>n>>k;
    if(k==1)
    {
        cout<<n;
        return 0;
    }
    product[0]=1;
    for(i=1;i<=500000;i++)
    {
        product[i]=product[i-1]*i;
        product[i]%=mod;
    }
    for(i=1;i<=k;i++)
    {
        int t=n/i;
        ans+=ncr(t-1,k-1);
        ans%=mod;
    }
    cout<<ans;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int>   II;
typedef vector< II >      VII;
typedef vector<int>     VI;
typedef vector< VI > 	VVI;
typedef long long int 	LL;
typedef vector<LL> 		VL;
typedef unsigned long long int ULL;

#define PB push_back
#define MP make_pair
#define F first
#define S second
#define SZ(a) (int)(a.size())
#define ALL(a) a.begin(),a.end()
#define SET(a,b) memset(a,b,sizeof(a))
#define LET(x,a) __typeof(a) x(a)

#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
//Works for forward as well as backward iteration

#define gu getchar
#define pu putchar
#define si(n) cin>>n
#define dout(n) cout<<n<<"\n"

#define DRT() int t; si(t); while(t--)

#define PlUSWRAP(index,n) index = (index+1)%n		//index++; if(index>=n) index=0
#define MINUSWRAP(index,n) index = (index + n -1)%n 	//index--; if(index<0) index=n-1
#define ROUNDOFFINT(d) d = (int)((double)d + 0.5)	//Round off d to nearest integer

#define FLUSHN while(gu()!='\n')
#define FLUSHS while(gu()!=' ')

#define TRACE

#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
	cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
	const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

#define off ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)

// set_name.find_by_order(k) It returns to an iterator to the kth element (counting from zero) in the set in O(logn) time
// set_name.order_of_key(k) It returns to the number of items that are strictly smaller than our item k in O(logn) time.
const int MAX = (int)(5e5 + 50);
const int INF = (int)(998244353);
LL fac[MAX], finv[MAX], inv[MAX];

// function for find inverse
LL inverse(LL a, LL mod){
 return 1<a ? mod - inverse(mod%a,a)*mod/a : 1;
}

void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; ++i) {
        fac[i] = fac[i - 1] * i%INF;
        inv[i] = INF - inv[INF%i] * (INF / i) % INF;
        finv[i] = finv[i - 1] * inv[i] % INF;
    }
}
LL COM(int n, int k) {
    if (n < k)return 0;
    if (n < 0 || k < 0)return 0;
    return fac[n] * (finv[k] * finv[n - k] % INF) % INF;
}
LL prime[MAX];
vector<LL> primes;
void seive(LL n){
	prime[1] = 0;
	for(LL i = 2;i*i <= n;i++){
		if(prime[i]){
			primes.PB(i);
			for(LL j = i*i ; j<=n;j+= i){
				prime[j] = 0;
			}
		}
	}
}
int main() {
	#ifndef ONLINE_JUDGE
    freopen("../input.txt", "r", stdin);
    freopen("../output.txt", "w", stdout);
	#endif
	srand(chrono::steady_clock::now().time_since_epoch().count());
	off;
	COMinit();
	rep(i,0,500005)
	prime[i] = 1;
	seive(500005);
	LL n,k;
	cin>>n>>k;
	if(k == 1){
		cout<<n;
		return 0;
	}
	if(n < k){
		cout<<0;
		return 0;
	}
	LL ans = COM(n-1, k-1);
	// cout<<"sz : "<<SZ(primes)<<"\n";

	for(auto pr : primes){
		LL div = n/pr;
		if(div >= k){
			ans = (ans + COM(div, k))%INF;
		}
	}
	cout<<ans;
  	return 0;
}

//https://codeforces.com/contest/1359/problem/E
//Author: BrownieTK

//#pragma GCC optimize("O3")

#include <bits/stdc++.h>
using namespace std;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

//========================Debug======================================

void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }

template <typename T, typename V>
void __print(const pair<T, V> &x)
{
    cerr << '{';
    __print(x.first);
    cerr << ',';
    __print(x.second);
    cerr << '}';
}
template <typename T>
void __print(const T &x)
{
    int f = 0;
    cerr << '{';
    for (auto &i : x)
        cerr << (f++ ? "," : ""), __print(i);
    cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v)
{
    __print(t);
    if (sizeof...(v))
        cerr << ", ";
    _print(v...);
}
#ifdef local
#define debug(x...)               \
    cerr << "[" << #x << "] = ["; \
    _print(x)
#else
#define debug(x...)
#endif

//========================TypeDefs===================================

typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ldb;

typedef pair<lli, lli> pll;
typedef pair<int, int> pii;
typedef pair<int, lli> pil;

//=========================MACROS====================================

#define pb push_back
#define popb pop_back()
#define pf push_front
#define popf pop_front()
#define si size()
#define be begin()
#define en end()
#define all(v) v.be, v.en
#define mp make_pair
#define mt make_tuple
#define acc(v) accumulate(all(v), 0)
#define F first
#define S second

#define forz(i, n) for (int i = 0; i < n; i++)
#define fore(i, m, n) for (int i = m; i <= n; i++)
#define rforz(i, n) for (int i = n - 1; i >= 0; i--)
#define rfore(i, m, n) for (int i = n; i >= m; i--)

#define deci(n) fixed << setprecision(n)
#define high(n) __builtin_popcount(n)
#define highll(n) __builtin_popcountll(n)
#define parity(n) __builtin_parity(n)
#define clz(n) __builtin_clz(n)
#define clzll(n) __builtin_clzll(n)
#define ctz(n) __builtin_ctz(n)

#define bset(a, p) ((a) | (1ll << (p)))
#define bchk(a, p) ((a) & (1ll << (p)))
#define bxor(a, p) ((a) ^ (1ll << (p)));
#define brem(a, p) (bchk(a, p) ? (bxor(a, p)) : (a))

#define lb lower_bound
#define ub upper_bound
#define er equal_range

#define findnot find_first_not_of

#define maxe *max_element
#define mine *min_element

#define mod2 1000000007
#define mod 998244353
#define PI 3.1415926535897932384
#define INF LLONG_MAX

#define gcd __gcd
#define kira ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)

#define endl "\n"
#define p0(a) cout << a << " "
#define p1(a) cout << a << endl
#define p2(a, b) cout << a << " " << b << endl
#define p3(a, b, c) cout << a << " " << b << " " << c << endl
#define p4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl

#define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define osetlli tree<lli, null_type, less<lli>, rb_tree_tag, tree_order_statistics_node_update>

#define ofk order_of_key
#define fbo find_by_order
//member functions :
//1. order_of_key(k) : number of elements sbtriectly lesser than k
//2. find_by_order(k) : k-th element in the set

//==============================FUNCTIONS===========================================

auto clk = clock();
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
void run_time()
{
#ifdef local
    cout << endl;
    cout << "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
    return;
}

inline lli power(lli x, lli y, lli p = mod)
{
    lli res = 1;
    x = x % p;
    while (y > 0)
    {
        if (y & 1)
            res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}

inline lli modadd(lli a, lli b, lli m = mod)
{
    a += b;
    if (a >= m)
        a -= m;
    return a;
}

inline lli modmul(lli a, lli b, lli m = mod)
{
    return ((a % m) * (b % m)) % m;
}

inline lli modi(lli a, lli m = mod) { return power(a, m - 2, m); }

//================================CODE=============================================
const int N = 5e5 + 5;
lli fac[N];
void fact()
{
    fac[0] = 1;
    for (int i = 1; i < N; i++)
    {
        fac[i] = (fac[i - 1] * i) % mod;
    }
    return;
}
lli ncr(lli a, lli b)
{
    if (a < b || a < 0 || b < 0)
        return 0;
    return ((fac[a] * modi(fac[b], mod)) % mod * modi(fac[a - b], mod)) % mod;
}
int main()
{
    kira;
    lli n,k;
    cin>>n>>k;
    lli ans=0;
    fact();
    if(k==1)
    {
        p1(n%mod);
        return 0;
    }
    for(lli i=1;i<=k-1;i++)
    {
        lli rem=(n)/i-1;
        ans=modadd(ans,ncr(rem,k-1));
    }
    p1(ans);
    run_time();
    return 0;
}

// https://codeforces.com/contest/1359/problem/E
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>

using namespace std;
#define lli long long int
#define mod 998244353

lli fact[500005];
lli inv_fact[500005];

lli bin_pow(lli a, lli b)
{
    lli ret=1;
    while(b)
    {
        if(b&1)
        {
            ret=(ret*a)%mod;
        }
        b >>= 1;
        a = (a*a)%mod;
    }
    return ret;
}

lli cmb(lli a, lli b)
{
    lli ret;
    ret=(((fact[a]*inv_fact[b])%mod)*inv_fact[a-b])%mod;
    return ret;
}

int main()
{
    lli n,k,sm=0,a,i;
    cin>>n>>k;
    a=max(n,k);
    fact[0]=1;
    inv_fact[0]=1;
    for(i=1;i<=a;i++)
    {
        fact[i]=(fact[i-1]*i)%mod;
        inv_fact[i]=bin_pow(fact[i],mod-2);
    }
    for(i=1;i<=n;i++)
    {
        a=(n/i)-1;
        a=cmb(a,k-1);
        if(a<0)
        {
            break;
        }
        sm=(sm+cmb(a,k-1))%mod;
    }
    cout<<sm<<"\n";
    return 0;
}

/* To Kaise Hain Aaplog*/

/* Yalgaar Ho */

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl

void shuru_krte_hai_bina_kisi_bakchodi_ke()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
}
const ll mod = 998244353;

ll power(ll x, ll y)
{
    ll res = 1;
    x = x % mod;

    if (x == 0)
        return 0;

    while (y > 0)
    {
        if (y & 1)
            res = (res * x) % mod;

        y = y >> 1;
        x = (x * x) % mod;
    }
    return res;
}

int main()
{
    shuru_krte_hai_bina_kisi_bakchodi_ke();
    ll n, k;
    cin >> n >> k;
    ll fact[n + 1];
    fact[1] = 1;
    fact[0] = 1;
    for (int i = 2; i <= n; i++)
    {
        fact[i] = fact[i - 1] * i;
        fact[i] %= mod;
    }
    if (n < k)
    {
        cout << 0 << "\n";
    }
    else if (k == 1)
    {
        cout << 1 << "\n";
    }
    else
    {
        ll ans = 0;
        ll i = 1;
        while (1)
        {
            ll nos = n / i - 1;
            if (nos < k - 1)
            {
                break;
            }
            ll val = (fact[k - 1] * fact[nos - k + 1]) % mod;
            ans = (ans+ ((fact[nos] % mod) * (power(val,mod-2) % mod)) % mod)%mod;
            i++;
        }
        cout << ans << "\n";
    }
    return 0;
}

//#pragma GCC optimize(2)
//#pragma GCC target ("sse4")
#include<bits/stdc++.h>
//typedef long long ll;
#define ull       unsigned long long
#define int       long long
#define F           first
#define S           second
#define endl        "\n"//<<flush
#define eps         1e-6
#define base        131
#define lowbit(x)   (x&(-x))
#define PI          acos(-1.0)
#define inf         0x3f3f3f3f
#define MAXN        0x7fffffff
#define INF         0x3f3f3f3f3f3f3f3f
#define ferma(a,b)  pow(a,b-2)
#define pb          push_back
#define decimal(x)  cout << fixed << setprecision(x);
#define all(x)      x.begin(),x.end()
#define memset(a,b) memset(a,b,sizeof(a));
#define IOS         ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
using namespace std;
void file()
{
#ifdef ONLINE_JUDGE
#else
    freopen("D:/LSNU/codeforces/duipai/data.txt","r",stdin);
    //  freopen("D:/LSNU/codeforces/duipai/WA.txt","w",stdout);
#endif
}
const int N=5e+5;
const int mod=998244353;
int A[N];
void init()
{
    A[0]=1;
    for(int i=1;i<=5e5;i++)
        A[i]=A[i-1]*i%mod;
}
int pow(int a,int b)
{
    int ans=1;
    while(b)
    {
        if(b&1)
            ans=ans*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return ans;
}
int C(int n,int m)
{
    if(n<m||n<0)
        return 0;
    int ans=A[n]*ferma(A[n-m],mod)%mod*ferma(A[m],mod)%mod;
}
signed main()
{
    IOS;
    file();
    init();
    int n,k;
    cin>>n>>k;
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        ans=(ans+C(n/i-1,k-1))%mod;
    }
    cout<<ans<<endl;

    return 0;
}

#include<bits/stdc++.h>

using namespace std;

const int N = 500001;
const int MOD = 998244353;

int fact[N];

int add(int x, int y) {
  x += y;
  while (x >= MOD)
    x -= MOD;
  while (x<0)
    x += MOD;
  return x;
}

int mul(int x, int y) {
  return (x * 1ll * y) % MOD;
}
void calculate_fact() {
  fact[1] = 1;
  for (int i = 2; i < N; i++)
  {
    fact[i] = mul(i,fact[i - 1]);
  }
}

int binpow(int x, int y)
{
	int z = 1;
	while(y > 0)
	{
		if(y % 2 == 1)
			z = mul(z, x);
		x = mul(x, x);
		y /= 2;
	}
	return z;
}

int inv(int x)
{
	return binpow(x, MOD - 2);
}

int divide(int x, int y) {
  return mul(x, inv(y));
}

int calculate_combinations(int select_from, int to_select) {

  return divide(fact[select_from], mul(fact[select_from-to_select], fact[to_select]));
}

int main() {
  int n, k;
  cin >> n;
  cin >> k;
  calculate_fact();
  if (k > n)
  {
    cout << 0 << "\n";
  }
  int total = 0;
  int looper = floor(n * 1.0 / k);
  for (int i = 1; i <= looper; i++)
  {

    int select_from = floor(n * 1.0 / i) - 1;
    int to_select = k - 1;
    total = add(total, calculate_combinations(select_from, to_select)) ;
  }
  cout << total << "\n";
}

#include <iostream>
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ifstream f("date.in");
ofstream g("date.out");
int T,Z;

ll mod=998244353;
ll fact[500005];
ll lgpow(ll n, ll p)
{
    ll r=1;
    while(p)
    {
        if(p%2==1)
        {
            r=(1LL*r*n)%mod;
        }
        n=(1LL*n*n)%mod;
        p=p/2;
    }
    return r;
}
ll comb(ll n,ll k)
{
    ll sus=1,jos=1;
    if(k==0)
    {
        return 1;
    }
    if(k>n) return 0;
    if(k==n) return 1;
    ll ans=((fact[n]*lgpow(fact[k],mod-2)))%mod;
    ans=ans*lgpow(fact[n-k],mod-2)%mod;
}
int main()
{

    T=1;
    while(T--)
    {
        ll n,k;
        cin>>n>>k;
        if(k==1)
        {
            cout<<n;
            return 0;

        }
        if(k>n)
        {
            cout<<0;
            return 0;
        }
        long long sol=0;
        fact[0]=1;
        for(int i=1;i<=n;i++)
        {
            fact[i]=(fact[i-1]*1LL*i)%mod;
        }
        for(int start=1;start<=n/k;start++)
        {
            sol=(sol+comb(n/start-1,k-1))%mod;
        }
        cout<<sol<<'\n';

    }

    }

#include<bits/stdc++.h>

using namespace std;

long long modulo(long long a,long long b,long long c){
long long x=1,y=a; // long long is taken to avoid overflow of intermediate results
while(b > 0){
if(b%2 == 1){
x=(x*y)%c;
}
y = (y*y)%c; // squaring the base
b /= 2;
}
return x%c;
}

bool primes[500002];

void solve() {
  int n, k;
  cin >> n >> k;
  long long MOD = 998244353;

  long long fact[500002];
  long long invFact[500002];
  fact[0]=1;
  for(long long i = 1; i <= 500000; i++){
      fact[i]=(fact[i-1]*i)%MOD;
  }
  invFact[500000] = modulo(fact[500000],MOD-2,MOD);
  for(long long i = 500000; i > 0; i--){
      invFact[i-1]=(invFact[i]*i)%MOD;
  }
  for(int i = 0; i <= 500000; i++)
    primes[i]=true;
  if(n<k){
      cout << 0 << endl;
  } else if(n==k) {
      cout << 1 << endl;
  } else {
      long long ans1 = (fact[n-1]*invFact[k-1])%MOD;
      ans1 = (ans1*invFact[n-k])%MOD;

      for(int i = 2; i <= n; i++) {
          if(primes[i]) {
            for(int j = i+i; j<= n; j+=i){
                primes[j]=false;
            }
            int h = n/i;
            if(h>0&&h>=k){
                cout << h << " " << k << endl;
                long long ans2 = (fact[h-1]*invFact[k-1])%MOD;
                ans2 = (ans2*invFact[h-k])%MOD;
                ans1 = (ans1+ans2)%MOD;
            }
          }
      }
      cout << ans1 << endl;
  }
}

int main() {
    ios_base::sync_with_stdio(false);
    //int t; cin >> t; while(t--)
    solve();
}

#include<bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef vector< ll > vi;
typedef vector< vi > vvi;
typedef pair< ll,ll > pl;
#define fori(i,a,b) for(i=a;i<b;i++)
#define ford(i,a,b) for(i=a;i>b;i--)
#define getv(a) fori(i,0,a.size()) cin>>a[i];
#define putv(a) for(auto x : a) cout<<x<<" ";
#define check cout<<"yo"<<flush;
#define MAXN 100001
#define MOD 998244353

ll gcdExtended(ll a, ll b, ll *x, ll *y){
    if(a == 0){
        *x = 0, *y = 1;
        return b;
    }
    ll x1, y1; // To store results of recursive call
    ll gcd = gcdExtended(b%a, a, &x1, &y1);

    *x = y1 - (b/a) * x1;
    *y = x1;

    return gcd;
}

ll modInverse(ll b, ll m){
    ll x, y; // used in extended GCD algorithm
    ll g = gcdExtended(b, m, &x, &y);

    if (g != 1) return -1;
    return (x%m + m) % m;
}

ll modDivide(ll a, ll b, ll m){
    a = a % m;
    ll inv = modInverse(b, m);
    if (inv == -1) return -1;
    else return (inv * a) % m;
}

ll C(ll n, ll x){
    if(x > n) return 0;
    x = min(x, n - x);
    ll one = 1, two = 1;
    while(x){
        one = (one * n)%MOD;
        n--;
        two = (two * x)%MOD;
        x--;
    }
    one = modDivide(one, two, MOD);
    return one;
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    #ifndef ONLINE_JUDGE
    freopen("O:\\programs\\cpp\\input.txt", "r", stdin);freopen("O:\\programs\\cpp\\output.txt", "w", stdout);
    #endif

    ll n, k;
    cin>>n>>k;
    ll ans = (C(n-1,k-1) + C((n-2)/2,k-1)) % MOD;
    cout<<ans;
    return 0;
}

/*
500000 1
*/
#include <bits/stdc++.h>
using namespace std;
using ll = long long; using ld = long double; using pii = pair<int, int>; const int N = 5e5 + 5, M = 998244353, INF = 0x3f3f3f3f; void Main();
void dprint() { cerr << '\n'; } template<typename T, typename ...U> void dprint(const T& x, const U& ...y) { ((sizeof ...(y) == 0) ? (cerr << x) : (cerr << x << ' ')); dprint(y...); } template<typename T> void dprint(const T& a, int l, int r, char c) { for (int i = l; i <= r; ++i) { cerr << a[i]; if (i == r) cerr << '\n'; else cerr << c;  } } template<typename ...U> void debug(const U& ...y) { cerr << "debug: "; dprint(y...); };
void print() { cout << '\n'; } template<typename T, typename ...U> void print(const T& x, const U& ...y) { ((sizeof ...(y) == 0) ? (cout << x) : (cout << x << ' ')); print(y...); } template<typename T> void print(const T& a, int l, int r, char c) { for (int i = l; i <= r; ++i) { cout << a[i]; if (i == r) cout << '\n'; else cout << c;  } }
void input() {} template<typename T, typename ...U> void input(T& x, U& ...y) { cin >> x; input(y...); } template<typename T> void input(T& a, int l, int r, bool f) { for (int i = l; i <= r; ++i) cin >> a[i]; }
template<typename T> void Max(T &a, T b) { a < b ? a = b : 1; } template<typename T> void Min(T& a, T b) { a > b ? a = b : 1; } template<typename T> void Add(T& a, T b) { a += b, a > M ? a -= M : 1, a < 0 ? a += M : 1; } template<typename T> void Mul(T &a, T b) { a = a * b % M; } template<typename T> T Mod(const T a) { return (a % M + M) % M; }
int main(int argc, char **argv) {
  ios::sync_with_stdio(0), cin.tie(0); /* cout << setprecision(10) << fixed; */
  #ifdef Zmm
  freopen((string(*(argv)).substr(2, string(*(argv)).size() - 6) + string(".cpp")).c_str(), "r", stdin); string x; cin >> x;
  #endif
  /* fread(BUF1, 1, SIZE, stdin); */ Main(); /* fwrite(BUF2, 1, buf2 - BUF2, stdout); */
}
ll qpow(ll a, ll b) {
  ll ret = 1;
  while (b) {
    if (b & 1) ret = a * ret % M;
    a = a * a % M, b >>= 1;
  }
  return ret;
}
ll fact[N], finv[N];
void init(int n) {
  fact[1] = 1;
  for (int i = 2; i <= n; ++i) fact[i] = fact[i - 1] * i % M;
  finv[n] = qpow(fact[n], M - 2);
  for (int i = n - 1; i >= 1; --i) finv[i] = finv[i + 1] * (i + 1) % M;
}
ll C(ll n, ll m) {
  if (n < m) return 0;
  // if (m == 0 || m == n) return 1;
  return fact[n] * finv[m] % M * finv[n - m] % M;
}
void Main() {
  int n, k;
  input(n, k);
  if (n < k) return print(0);
  init(n);
  ll ans = 0;
  for (int i = 1; i <= n - k + 1; ++i) {
    ll x = n / i;
    // if (x < k) break;
    Add(ans, C(x - 1, k - 1));
    // print(i, C(x - 1, k - 1), x - 1, k - 1);
    // if (i == 3) break;
  }
  print(ans);
}

#include <bits/stdc++.h>
#define int long long int
//#define double long double
using namespace std;

const int mod=  998244353;

int power(int a,int b,int m) { int ans=1; a=a%m; while(b>0) { if(b&1) ans=(1LL*a*ans)%m; b>>=1; a=(1LL*a*a)%m; } return ans; }
int ncr(int n,int r){ int res=1; if(r>n-r)r=n-r; for(int i=0;i<r;i++) {  res*=n-i;  res/=i+1; } return res; }
int gcd(int a,int b){ if(b==0) return a;  return gcd(b,a%b); }
int lcm(int a,int b){ return (a* b)/gcd(a,b); }
//void fenupdate(int pos,int val){ if(pos>100004) return; fen[pos]+=val; update(pos+(pos&(-pos)),val); }
//int fensum(int pos) { int sm=0; while(pos>0) { sm+=fen[pos]; pos-=pos&(-pos); } return sm; }

signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    //cout<<"I must do it......Yeahhh!!!";

    int tt=1;
    //cin>>tt;
    int kk=0;
    pp:
    for(;kk<tt;kk++)
    {
        int n,k,ans=0;
        cin>>n>>k;
        if(k>n)
        {
            cout<<0;
            return 0;
        }
        for(int i=1;n/i>=k;i++)
            ans=(ans+ncr(n/i-1,k-1))%mod;

        cout<<ans%mod;

    }
    cerr<<"[Execution : "<<(1.0*clock())/CLOCKS_PER_SEC<<"s]\n";
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long double ld;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;

#define pb push_back
#define F first
#define S second
#define ALL(v) v.begin(),v.end()
#define fast_cin() ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);

#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

const int mod = 998244353;
const ll inf = 5e18;
const int MAX = 5e5 + 100;

ll fact[MAX], inv[MAX];

ll mypow(ll a, ll m, ll p) {
	ll res = 1;
	a %= p;
	while(m > 0) {
		if(m & 1) {
			res = (res * a) % p;
		}
		m /= 2;
		a = (a * a) % p;
	}
	return res;
}

ll getInverse(ll a) {
	return mypow(a, mod - 2, mod);
}

void pre() {
	fact[0] = 1;
	inv[0] = getInverse(1);
	for(ll i = 1; i < MAX; i++) {
		fact[i] = (fact[i - 1] * i) % mod;
		inv[i] = getInverse(fact[i]);
	}
}
ll choose(ll n, ll r) {
    return (((fact[n] * inv[n - r]) % mod) * inv[r]) % mod;
}

int main() {
    pre();
    ll n, k; cin >> n >> k;
    if(k == 1) {
        cout << n << endl;
        return 0;
    }
    ll N = n - 1, K = k - 1;
    ll ans = 0;
    if(K >= 2) {
        for(ll nr = K - 1; nr <= N - 1; nr++) {
            if(K < 0 or nr < 0) {
                continue;
            }
            ans += choose(nr - 1, K - 2) * (N - nr);
            ans %= mod;
        }
    } else if(K == 1) {
        ans = N;
    }
    trace(ans);
    for(ll i = 2; i <= N; i++) {
        N = n / i - 1, K = k - 1;
        if(N < K) {
            break;
        }
        // trace(N, K);
        for(ll nr = K - 1; nr <= N - 1; nr++) {
            // trace(nr, K - 2);
            ans += choose(nr - 1, K - 2) * (N - nr);
            ans %= mod;
        }
    }
    cout << ans << endl;
}

#include <bits/stdc++.h>

using namespace std;

typedef long double ld;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;

#define pb push_back
#define F first
#define S second
#define ALL(v) v.begin(),v.end()
#define fast_cin() ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);

#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

const int mod = 998244353;
const ll inf = 5e18;
const int MAX = 5e5 + 100;

ll fact[MAX], inv[MAX];

ll mypow(ll a, ll m, ll p) {
	ll res = 1;
	a %= p;
	while(m > 0) {
		if(m & 1) {
			res = (res * a) % p;
		}
		m /= 2;
		a = (a * a) % p;
	}
	return res;
}

ll getInverse(ll a) {
	return mypow(a, mod - 2, mod);
}

void pre() {
	fact[0] = 1;
	inv[0] = getInverse(1);
	for(ll i = 1; i < MAX; i++) {
		fact[i] = (fact[i - 1] * i) % mod;
		inv[i] = getInverse(fact[i]);
	}
}
ll choose(ll n, ll r) {
    return (((fact[n] * inv[n - r]) % mod) * inv[r]) % mod;
}

int main() {
    pre();
    ll n, k; cin >> n >> k;
    if(k == 1) {
        cout << n << endl;
        return 0;
    }
    ll N = n - 1, K = k - 1;
    ll ans = 0;
    if(K >= 2) {
        for(ll nr = K - 1; nr <= N - 1; nr++) {
            ans += choose(nr - 1, K - 2) * (N - nr);
            ans %= mod;
        }
    } else if(K == 1) {
        ans = N;
    }
    trace(ans);
    for(ll i = 2; i <= N; i++) {
        N = n / i - 1, K = k - 1;
        if(N < K) {
            break;
        }
        for(ll nr = K - 1; nr <= N - 1; nr++) {
            ans += choose(nr - 1, K - 2) * (N - nr);
            ans %= mod;
        }
    }
    cout << (ans + mod) % mod << endl;
}

#include<iostream>
#include <bits/stdc++.h>
#define ll long long
#define ld  long double
#define IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const int mod=998244353, N=1e6+2;
int fastpower(int b, int p )
{
    if(p==0)
        return 1;
    int ans=fastpower(1LL*b*b%mod,p/2);
    return p%2 ? 1LL*ans*b%mod : ans;
}
int n, k, f[N], inv[N];
int ncr(int n, int r)
{
    if(r>n)
        return 0 ;
    return f[n] * (1LL*inv[n-r]*inv[r]%mod) %mod;
}
int main()
{
    IO
    cin>>n>>k;
    f[0]=inv[0]=inv[1]=1;
    for(int i=1; i<=1e6; i++)
    {
        f[i]=1LL*i*f[i-1]%mod;
        if(i>1)
        inv[i]=1LL*inv[i-1]*(mod-1LL*mod/i*inv[mod%i]%mod)%mod;
    }
    ll ans=0;
    for(int i=1; i<=n; i++)
    {
        ans+=ncr(n/i-1,k-1);
        if(ans>mod)
            ans%=mod;
    }
    cout<<ans;
}

#include<bits/stdc++.h>
using namespace std;
#define imt long long
const int MX = 1e6 + 1, MOD = 1e9;
int a[MX], n, k, h, c, m, x, y, ans = 0;
int fact[MX];
int add(int x, int y){
    x = x + y;
    while(x >= MOD) x -= MOD;
    while(x < 0) x += MOD;
    return x;
}
int mul(int x, int y){
    return (x * 1ll * y) % MOD;
}
int pow(int x, int y){
    int z = 1;
    while(y > 0){
        if(y & 1) z = mul(z, x);
        x = mul(x, x);
        y = y / 2;
    }
    return z;
}
int inv(int x){
    return pow(x, MOD - 2);
}
int divide(int x, int y){
    return mul(x, inv(y));
}
void precal(){
    fact[0] = 1;
    for(int i = 1; i < MX; i++) fact[i] = mul(fact[i - 1], i);
}
int C(int n, int k){
    if(n < k) return 0;
    return divide(fact[n], mul(fact[k], fact[n - k]));
}
int32_t main()
{
//    ios_base::sync_with_stdio(false);
//    cin.tie(NULL);
    /*
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    */
    int t = 1;
//    cin>>t;
    while(t--){
        cin>>n>>k;
        long long ans = 0;
        for(int i = 1; i <= n; i++){
            int d = n / i;
            ans = add(ans, C(d - 1, k - 1));
        }
        cout<<ans<<"\n";
    }
}

#include<iostream>
#include<stack>
#include<map>

using namespace std;
long long MOD=998244353LL;
long long N,K;
long long fact[500050];
long long inv[500050];

long long bp (long long a,long long b) {
    a%=MOD;
    if (b==0)return 1;
    long long t = bp(a,b/2);
    t=(t*t)%MOD;
    if (b%2==1) {
        t=(t*a)%MOD;
    }
    return t;
}
int main () {
    ios_base::sync_with_stdio(0); cin.tie(0);
    cin >> N>>K;
    fact[0]=1;
    for (long long i =1; i <=500010; i++) {
        fact[i]=i*fact[i-1];
        fact[i]%=MOD;
        inv[i]=bp(fact[i], MOD-2);
    }
    if (N  < K){
        cout <<0;
        return 0;
    }
    if (N==K){
        cout << 1;
        return 0;
    }
    if (K==1) {
        cout << N;
        return 0;
    }
    long long ans=0;
    for (long long i =1; i<= N; i++) {
        if (N/i<K)break;
        ans+= (((fact[N/i-1]*inv[K-1])%MOD)*inv[N/i-K])%MOD;
        ans%=MOD;
    }
    cout << ans;

    return 0;
}

#include<bits/stdc++.h>
using namespace std;

#define double long double
#define int long long
#define ALL(x) x.begin(),x.end()
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define pb(x) push_back(x)
#define eb emplace_back
#define SORT(ls) sort(ls.begin(), ls.end())
#define DESC(ls) sort(ls.rbegin(), ls.rend())
#define mp(x, y) make_pair(x, y)
#define INF 1000000000
#define MOD 998244353
#define F(i, a, n) for(i=a;i<n;i++)
#define SI(x) cin>>x
#define DI(x, y) cin>>x>>y
#define TI(x, y, z) cin>>x>>y>>z
#define FI(w, x, y, z) cin>>w>>x>>y>>z
#define SO(x) cout<<x<<"\n"
#define DO(x, y) cout<<x<<" "<<y<<"\n"
#define TO(x, y, z) cout<<x<<" "<<y<<" "<<z<< "\n"
#define FO(w, x, y, z) cout<<w<<" "<<x<<" "<<y<<" "<<z<<"\n"
#define FASTER ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

inline int add(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline void inc(int& a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
inline void dec(int& a, int b) { a = sub(a, b); }

int factorial[1000000];

void fillFactorial()
{
    int i;
    factorial[0] = 1;
    F(i, 1, 1000000)
    {
        factorial[i] = (factorial[i - 1] * i) % MOD;
    }
}
long long binpow(long long a, long long b, long long m)
{
    a %= m;
    long long res = 1;
    while (b > 0) {
        if (b & 1)
            res = res * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return res;
}

int inverse(int x)
{
    return binpow(x, MOD - 2, MOD);
}

long long combination(int n, int k) {
    return (factorial[n] * inverse(factorial[k]) % MOD) % MOD * inverse(factorial[n - k]) % MOD;
}

int32_t main(void)
{
    FASTER;
    #ifdef LOCAL
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    int i, j;
    fillFactorial();
    int ans = 0;
    int n, k;
    DI(n,k);
    F(i, 1, n+1)
    {
        int q = n/i;
        inc(ans, combination(q-1,k-1));
    }
    SO(ans);
    #ifdef LOCAL
    	cout<<endl<<endl<<"Time: "<<(float)clock()/CLOCKS_PER_SEC<<" seconds"<<endl;
    #endif
    return 0;
}

#include  <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = 5e5+10, mod = 998244353;

ll sum(ll x){
    return ((x*(x+1LL))/2LL)%mod;
}

typedef long long ll;

ll factorial[maxn];

ll exp(ll b, ll p){

    ll resp = 1;

    b = b % mod;

    while(p > 0){
        if(p & 1){
            resp = (resp * b)%mod;
        }
        p = p >> 1;
        b = (b * b)%mod;
    }

    return resp;
}

ll inverse(ll x){
    return exp(x, mod-2);
}

ll ncr(ll n, ll k) {
    return factorial[n] * inverse(factorial[k]) % mod * inverse(factorial[n - k]) % mod;
}

int32_t main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

    ll n, k;

    cin >> n >> k;

    if(k == 1){
        cout << n << endl;
        return 0;
    }
    if(n < k){
        cout << 0 << endl;
        return 0;
    }

    factorial[0] = 1LL;

    for(ll i=1; i<=n; i++){
        factorial[i] = (factorial[i - 1] * i) % mod;
    }

    long long ans = 0LL;

    for(ll i=1; i<=k; i++){
        ll div = n/i;

        div--;

        if(div >= k-1) ans = (ans + ncr(div, k-1))%mod;
    }

    cout << ans << endl;

	return 0;
}

#include<bits/stdc++.h>

using namespace std;

#define FOR(i, j, k) for(int i = j; i <= k; i++)
#define ROF(i, j, k) for(int i = j; i >= k; i--)
#define PB push_back
#define MEM(n, val) memset((n), val, sizeof(n))
#define FastIO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define F first
#define S second
#define MP make_pair
#define LL long long
#define MOD 1000000007
#define MX 200010
#define INFL 1000000000000000000LL
#define INF 1000000000

typedef pair<int, int> PII;

int n, k;

bool vis[1010][1010];
PII dp[1010][1010];

PII func(int pos, int cur_k) {
    if(pos == 0) {
        if(cur_k != 0) {
            return {0, 0};
        }
        /// total no. of ways, count of 1
        return {1, 0};
    }

    if(vis[pos][cur_k]) {
        return dp[pos][cur_k];
    }

    PII ans = {0, 0};

    /// ekhane fixed k boshiye
    if(cur_k > 1) {
        ans.F += func(pos - 1, cur_k - 1).F;
        ans.S += func(pos - 1, cur_k - 1).S;

        /// ekhane k - 2 ta element boshiye except 1 and k itself
        ans.F += (k - 2) * func(pos - 1, cur_k).F;
        ans.S += (k - 2) * func(pos - 1, cur_k).S;
    }

    if(cur_k <= 1) {
        /// ekhane k - 1 ta element boshiye except 1 and k itself
        ans.F += (k - 1) * func(pos - 1, cur_k).F;
        ans.S += (k - 1) * func(pos - 1, cur_k).S;
    }

    /// ekhane fixed 1 boshiye
    if(cur_k == 1) {
        ans.F += func(pos - 1, cur_k - 1).F;
        ans.S += func(pos - 1, cur_k - 1).F + func(pos - 1, cur_k - 1).S;
    }
    else {
        ans.F += func(pos - 1, cur_k).F;
        ans.S += func(pos - 1, cur_k).F + func(pos - 1, cur_k).S;
    }

//    cout << pos << " " << cur_k << " : " << ans.F << " " << ans.S << "\n";
    vis[pos][cur_k] = 1;
    return dp[pos][cur_k] = ans;
}

int main() {
//    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
    FastIO;
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

    cin >> n;

    vector<int> ans;

    int inc = 0;
    ROF(i, n, 1) {
        MEM(vis, 0);
        cout << "\nk = " << i << "\n";
        k = i;
        inc += func(n, i).S;
//        ans.PB(func(n, i).S);
//        func(n, i).S;
//        cout << func(n, i).S << "\n";
        cout << inc << "\n";
    }
//    sort(ans.begin(), ans.end(), greater<int>());
//    FOR(i, 0, n - 1) {
//        cout << ans[i] << " ";
//    }
    return 0;
}
/**
41 39 15 1
*/

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vl;
typedef vector<vector<long long>> vvl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<pair<int,int>> vii;
typedef vector<pair<long long,long long>> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
const int INF = INT_MAX;
const ll LL_INF = LLONG_MAX;
#define pb push_back
#define LOOP(x, a, b) for(int x = a; x < b; ++ x)
#define LOOPD(x, a, b) for(int x = a; x >= b; -- x)
#define mp make_pair
#define fi first
#define se second

const int MOD = 998244353;

int plus_mod(int a , int b){
	ll x = (long long)a + b;
	if(x<-1*MOD)x += 2*MOD;
	else if(x<0)x += MOD;
	else if(x>=MOD) x -= MOD;
	return (int)x;
}
int minus_mod(int a,int b){
	int x = a-b;
	if(x<-1*MOD)x += 2*MOD;
	else if(x<0)x += MOD;
	else if(x>=MOD) x -= MOD;
	return x;
}
int multiply(int a,int b){
	ll x = ((long long)a*b)%MOD;
	if(x<0) x += MOD;
	return (int)x;
}

void print_vector(vi& v){
	for(int i:v)cout<<i<<" ";
	cout<<'\n';
}
void print_array(int a[],int s,int e){
	LOOP(i,s,e)cout<<a[i]<<" ";
	cout<<'\n';
}

const int MAXN = 500005;
int inv[500005];
int fact[500005];
int ivf[500005];

void preprocess(){
	inv[1]=1;
	ivf[1] = 1;
	ivf[0] = 1;
	fact[0]=fact[1]=1;
	LOOP(i,2,MAXN){
		inv[i] = (MOD-((long long)(MOD/i)*inv[MOD%i])%MOD)%MOD;
		fact[i] = multiply(i,fact[i-1]);
		ivf[i] = multiply(inv[i],ivf[i-1]);
	}

}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int T;
	//cin>>T;
	T = 1;
	while(T--){

		int n,k;
		preprocess();
		cin>>n>>k;
		int val = 1;
		LOOPD(i,n-1,n-k+1){
			val = multiply(val,i);
			val = multiply(val,inv[(n-1-i+1)]);
		}
		int ans=val;

		LOOP(i,2,MAXN){
			int val = max(n/i-1,0);
			int x=0;
			if(val>=(k-1)&&(k-1))x = multiply(fact[val],multiply(ivf[k-1],ivf[val-k+1]));
			ans = plus_mod(ans,x);

		}

		cout<<ans<<'\n';
	}
}

#include <iostream>
#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define INF 1000000000
#define MOD 1000000007
#define M 998244353
#define fori(i, a, b) for(i=a; i<b; i++)
#define ford(i, a, b) for(i=a; i>b; i--)
using namespace std;
const ll N = 500043;
ll fact[N];
ll add(ll x, ll y)
{
	x += y;
	while(x >= MOD) x -= MOD;
	while(x < 0) x += MOD;
	return x;
}
ll mul(ll a, ll b)
{
    ll res = 0;
    a = a % MOD;
    while (b>0)
    {
        if (b % 2 == 1)
            res = (res + a) % MOD;
        a = (a * 2) % MOD;
        b /= 2;
    }
    return res % MOD;
}
ll binpow(ll x, ll y)
{
	ll z = 1;
	while(y > 0)
	{
		if(y % 2 == 1)
			z = mul(z, x);
		x = mul(x, x);
		y /= 2;
	}
	return z;
}
ll inv(ll x)
{
	return binpow(x, MOD - 2);
}
ll divide(ll x, ll y)
{
	return mul(x, inv(y));
}
void precalc()
{
	fact[0] = 1;
	for(ll i = 1; i < N; i++)
		fact[i] = mul(i, fact[i - 1]);
}
ll C(ll n, ll k)
{
	if(k > n)
	    return 0;
	return
	    divide(fact[n], mul(fact[n - k], fact[k]));
}

ll solve()
{
    ll n, k;
	cin >> n >> k;
	precalc();
	ll ans = 0;
	ll i, div;
	fori(i, 1, n+1)
	{
		div = n/i;
		ans = add(ans, C(div-1, k-1));
	}
	return ans;
}

int main()
{
    io
    ll t;
    t=1;
    // cin >> t;
    while(t--)
        cout << solve() << endl;
    return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <vector>
#include <map>
#include <stack>
using namespace std;
typedef long long ll;
#define pii pair<int, int>
#define mk make_pair
const int N = 1e6 + 10;
const int mod = 998244353;
ll qpow(ll a, ll x, ll mo)
{
    ll res = 1;
    while (x)
    {
        if (x & 1)
            res = 1ll * res * a % mod;
        a = 1ll * a * a % mod;
        x >>= 1;
    }
    return res;
}
int fac[N], facinv[N];
void prepare()
{
    fac[0] = 1;
    facinv[0] = 1;
    for (int i = 1; i < N; i++)
        fac[i] = 1ll * fac[i - 1] * i % mod;
    facinv[N - 1] = qpow(fac[N - 1], mod - 2, mod);
    for (int i = N - 2; i >= 1; i--)
        facinv[i] = 1ll * facinv[i + 1] * (i + 1) % mod;
}
ll C(ll n, ll i)
{
    if (n <= 0)
        return 0;
    if (i > n)
        return 0;
    if (i == 0)
        return 1;
    return 1ll * fac[n] * facinv[i] % mod * facinv[n - i] % mod;
}
int n, k;
int main()
{
    prepare();
    cin >> n >> k;
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        ans = (ans + C(n / i - 1, k - 1)) % mod;
    }
    cout << ans << endl;
}

#include <bits/stdc++.h>

#define int int64_t
#define pb push_back
#define Start_time clock_t startTime = clock();
#define End_time clock_t endTime = clock(),clockTicksTaken = endTime - startTime;double t = clockTicksTaken / (double) CLOCKS_PER_SEC;cout<<sp(t)<<endl;
#define ibswsct() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define gcd __gcd
#define s second
#define f first
#define sp(x) setprecision(13) << fixed << x

using namespace std;

typedef pair<int,int> pii ;
typedef pair<pair<int,int>,int> pii_i ;
typedef pair<int,pair<int,int> > pi_ii ;
typedef pair<pair<int,int>,pair<int,int> > piiii ;
// for order_of_key():
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>  ordered_set;

const int N = 5e5 + 10, mod = 998244353;
int n, k, fac[N];

int power(int x, int y = mod - 2){
    if(y == 0){
        return 1;
    }
    int ret = power(x, y >> 1);
    if(y & 1){
        return (((ret * ret) % mod) * x) % mod;
    }
    return (ret * ret) % mod;
}

int en(int x, int y){
    if(y < x){
        return 0;
    }
    if(x == 0){
        return 1;
    }
    int ret = en(x - 1, y - 1) + en(x, y - 1) % mod;
    return ret;
}

int32_t main(){
	ibswsct();
	cin >> n >> k;
	if(k == 1){
        cout << n;
        return 0;
	}
	fac[0] = 1;
	for(int i=1;i<=5e5;i++){
        fac[i] = (fac[i - 1] * i) % mod;
	}
	int ans = 0;
	cout << k - 1 << ' ' << n / 2 << ',' << k - 1 << ' ' << n - 1 << '\n';
	ans = en(k - 1, n / 2 - 1) + en(k - 1, n - 1);
	cout << ans;
}

//Chaos///

#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#if DEBUG && !ONLINE_JUDGE
    #define debug(args...)     (Debugger()) , args
    class Debugger
    {
        public:
        Debugger(const std::string& _separator = ", ") :
        first(true), separator(_separator){}
        template<typename ObjectType>
        Debugger& operator , (const ObjectType& v)
        {
            if(!first)
                std::cerr << separator;
            std::cerr << v;
            first = false;
            return *this;
        }
        ~Debugger() {  std::cerr << endl;}

        private:
        bool first;
        std::string separator;
    };
    template <typename T1, typename T2>
    inline std::ostream& operator << (std::ostream& os, const std::pair<T1, T2>& p)
    {
        return os << "(" << p.first << ", " << p.second << ")";
    }
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::vector<T>& v)
    {
        bool first = true;
        os << "[";
        for(unsigned int i = 0; i < v.size(); i++)
        {
            if(!first)
                os << ", ";
            os << v[i];
            first = false;
        }
        return os << "]";
    }
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::set<T>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii;
            first = false;
        }
        return os << "]";
    }
    template<typename T1, typename T2>
    inline std::ostream &operator << (std::ostream & os,const std::map<T1, T2>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii ;
            first = false;
        }
        return os << "]";
    }
#else
    #define debug(args...)
#endif
// const int mod = 1000000007;
const int mod = 998244353;
#define ok order_of_key
#define fo find_by_order
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ll long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define repp(i,n) for(int i=(0);i<(n);i++)
#define repr(i,n) for(int i=(n);i>=0;i--)
#define reprr(i,n) for(int i=(n);i>0;i--)
#define repl(i,a,b) for(ll i=(a);i<(b);i++)
#define newl cout<<'\n'
#define inf 1000000000
#define repaa(i,a) for(auto i=a.rbegin();i!=a.rend();++i)
#define pb push_back
#define test cout<<"test"<<endl
#define tc int tt;cin>>tt;while(tt--)
#define start int tt;tt=read();while(tt--)
#define startk int tt;cin>>tt;for(int kk=1;kk<=tt;kk++)
#define mem(v,i) memset(v,i,sizeof(v))//Use mem(v,60) to initialize with 10^9
#define all(x) x.begin(), x.end()
#define inf1 1e18
#define repa(i,a) for (auto i : a)
#define X first
#define Y second
#define lb lower_bound
#define ub upper_bound
#define gcd(a,b)    __gcd((a),(b))
#define lcm(a,b)    ((a)*(b)) / gcd((a),(b))
#define in(a,n) repp(jjj,n)cin>>a[jjj];
#define re(a,n) repp(jjj,n)a[jjj]=read();
#define retree(a,m) repp(i,m){int tmp1=read()-1,tmp2=read()-1;a[tmp1].eb(tmp2);a[tmp2].eb(tmp1);}
#define intree(a,m) repp(i,m){int tmp1,tmp2;cin>>tmp1>>tmp2;tmp1--,tmp2--;a[tmp1].eb(tmp2);a[tmp2].eb(tmp1);}
#define ins insert
#define case(ans) cout << "Case #" << kk << ':' << ' ' << ans << nl
#define er erase
#define sz(a) (int)(a.size())
#define print(x,n,k) repp(i,n){repp(j,k)cout<<x[i][j]<<"  ";newl;}
#define mt make_tuple
#define eb emplace_back
#define bpl(i) __builtin_popcountll(i)
#define bp(i) __builtin_popcount(i)
#define precision(x) cout << fixed << setprecision(x);
#define si set<int>
#define usi unordered_set<int>
#define sl set < ll >
#define usl unordered_set < ll >
#define sip set < ip >
#define sil set < il >
#define mi map<int , int >
#define umi unordered_map<int , int >
#define ml map < ll , ll>
#define uml unordered_map < ll , ll>
#define mip map<ip , int>
#define mmx(x1,x2) min(x1,x2) , max(x1,x2)
#define make_unique(x) sort(all((x))); (x).resize(unique(all((x))) - (x).begin())
#define mxe max_element
#define mne min_element
#define srt(v) sort(all(v))
#define rsrt(v) sort(v.rbegin(), v.rend())
#define yn {puts("YES");}else{puts("NO");}
typedef long double ld;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<ll> vl;
typedef vector < vi > vii;
typedef vector<pair<int,int>> vip;
typedef vector<pair<ll,ll>> vil;
typedef vector < vl > vll;
typedef pair<int, int> ip;
typedef pair<ll, ll> il;
typedef tuple<int,int,int> state;
typedef tuple<ll,ll,ll> statel;
const int dx[4]={1,0,0,-1};
const int dy[4]={0,1,-1,0};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const double eps = 1e-10;
const char nl = '\n';
const char sp = ' ';
#ifdef Fading
#define gc getchar
#endif
#ifndef Fading
inline char gc(){static char now[1<<16],*S,*T;if (T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}return *S++;}
#endif
inline ll read(){register ll x=0,f=1;char ch=gc();while (!isdigit(ch)){if(ch=='-')f=-1;ch=gc();}while (isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=gc();}return (f==1)?x:-x;}
template<typename T>T Min(T v) {return v;}template<typename T, typename... Args>T Min(T first, Args... args) {return min(first , Min(args...));}
template<typename T>T Max(T v) {return v;}
template<typename T, typename... Args> T Max(T first, Args... args) {return max(first , Max(args...));}
template<typename T> T mult(T v) {return v;} template<typename T, typename... Args>T mult(T first, Args... args) {return mult((first%mod * mult(args...))%mod);}
template<class T , class U> inline bool remax(T &a, U b) { return a < b ? a = b, 1 : 0; }
template<class T , class U> inline bool remin(T &a, U b) { return a > b ? a = b, 1 : 0; }
template<class A, class B> void add(A &a, B b){a += b;if(a >= mod) a -= mod;if(a < 0) a += mod;}
template<class A, class B> ll addr(A a, B b){a += b;if(a >= mod) a -= mod;if(a < 0) a += mod;return a;}
template<class T1,class T2>T2 min(T1 a,T2 b){return min((T2)a,b);}
template<class T1,class T2>T2 max(T1 a,T2 b){return max((T2)a,b);}
template<class A> void pnt(A a[],int st,int en) {rep(i,st,en) cout << a[i] << ' ' ; newl;}
template<class A> void pnt(A a[],int en) {repp(i,en) cout << a[i] << ' ' ; newl;}
template<class A> void pnt(vector<A>&a, char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A> void pnt(A &a , char tmp = '\n') {cout << a << tmp;}
template<class A> void pnt(set<A>&a , char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A> void pnt(unordered_set<A>&a, char tmp = '\n') {repa(i,a) cout << i << ' ' ; newl;}
template<class A ,class B> void pnt(pair<A,B>&a, char tmp = '\n'){cout << a.X << ' ' << a.Y << tmp;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v){return i>>v.X>>v.Y;}
template<typename T , typename A>void W(T v ,A &c) {pnt(v,c);}template<typename T, typename A , typename... Args>void W(T first,A &c , Args... args) {pnt(first,c) ; W(args...);}
template <class T1>void kill(T1 ans){pnt(ans);exit(0);}

ll nc2(ll a){return a * (a - 1) / 2;}
ll setbit(ll num, ll kk){ return 1LL*(num|(1LL<<kk)); }
ll unsetbit(ll num, ll kk){ return 1LL*(num&~(1LL<<kk)); }
ll invertbit(ll num, ll kk){ return 1LL*(num^(1LL<<kk)); }
bool kthbit(ll num, ll kk){ return num&(1LL<<kk); }
bool matchpar(ll a, ll b){return (a&1) == (b&1);}
ll mceil(ll a, ll b){return a/b + (ll)(a%b > 0);}
ll poww(ll a, ll b,ll m = mod){ll val = 1;a %= m;while (b > 0){if (b & 1) val = (a * val) % m;a = (a * a) % m;b >>= 1;}return val;}
ll inv(ll a){return poww(a , mod - 2);}
ll gcdll(ll x, ll y){return y == 0 ? x : gcdll(y, x % y);}
int mylog(ll x , ll y){if(x == 0) return -1;return mylog(x/y,y) + 1;}

//-----------------------------------------------------end--------------------------------------//

const int jj=2e5+5;
ll fac[jj];
void pre(){
    fac[0] = 1;
    for (int i=1 ; i<jj; i++)
    fac[i] = fac[i-1]*i%mod;
}
ll nc(int n,int r)
{
    if(n < r) return 0;
   if (r==0)
      return 1;
   return (fac[n]*inv(fac[r])%mod*inv(fac[n-r])%mod)%mod;
}

signed main()
{
    ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int n , k;
    pre();
    cin >> n >> k;
    ll ans = 0;
    rep(i,1,n){
        add(ans , nc(n/i - 1,k - 1));
    }
    W(ans , nl);
}

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#define ll long long int
// #define maxN 300009
// #define m 998244353
using namespace std;
typedef pair<long long int , long long int> tup;

long long int maxN = 300009;
long long int m = 998244353;

long long int power(long long int x,long long int y,long long int p)
    {
        long long int res = 1;

        x = x % p;
        while (y > 0)
        {
            if ( y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }

int main()
{
    long long int n , k;
    long long int count = 0, total = 0;
    cin >> n >> k;

    vector <long long int> fac(maxN + 1, 1);
    vector <long long int> modinv(maxN + 1 , 1);

    // Calculate factorial % m
    for(long long int i = 1; i < maxN; i++ )
        fac[i] = (fac[i - 1] * i) % m;

    // Calculate inverse % m
    for(long long int i = 0; i < maxN; i++)
        modinv[i] = power(fac[i] , m - 2 , m) % m;

    if (k == 1)
    {
        total = n % m;
    }

    else if (n > k)
    {
        for(long long int i = 1; i <= n; i++)
        {
            long long int N = n / i;
            if (N >= k)
                total += (((fac[N - 1] * modinv[k - 1]) % m) * modinv[N - k ]) % m;
            // cout << N << " " << k << "\n";
            total = total % m;
        }
    }

    else if (n == k)
    {
        total = 1;
    }

    else if (k > n)
    {
        total = 0;
    }

    cout << total << "\n";

    return 0;
}

#include "bits/stdc++.h"
using namespace std;

#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define pb push_back
#define f first
#define s second
#define nl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll MOD = 998244353;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

int n, k;
ll f[500001];

ll gcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = gcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll inv(ll a){
  ll x, y;
  ll g = gcd(a, MOD, x, y);
  return (x % MOD + MOD) % MOD;
}

ll choose(int n){
  return ((f[n]*inv(f[k-1]))%MOD*inv(f[n-k+1]))%MOD;
}

int main(){
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  cin.sync_with_stdio(0); cin.tie();
  cin.exceptions(cin.failbit);

  cin >> n >> k;

  f[1]=1;
  rep(i, 2, n){
    f[i]=(f[i-1]*i)%MOD;
  }

  ll ans=0;
  rep(i, 1, n){
    if(n/i<k) break;
    ans=(ans+choose(n/i-1))%MOD;
  }
  cout << ans;
}

//#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <map>
#include <cmath>
#include <iomanip>
#include <fstream>

using namespace std;

#define int long long
const int MX = 1e7;
int mod = 998244353;
int fast (int a, int n) {
    if (n == 0)
        return 1;
    if (n % 2 == 1)
        return (fast(a, n-1) * a)%mod;
    else {
        int b = fast(a, n/2);
        return (b * b) % mod;
    }
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n;
        exit(0);
    }
    int ans = 0;

    vector<int> two(MX, 1);
    for (int i = 1; i < MX; ++i) {
        two[i] = two[i - 1] * i;
        two[i] %= mod;
    }
    for (int i = 1; i <= n; ++i) {
        int cnt = n / i;
        if (cnt >= k) {
            cnt--;
            ans += two[cnt];
            ans %= mod;
            ans *= fast(two[k - 1], two[k - 1] - 1);ans %= mod;
            ans *= fast(two[cnt - k + 1], two[cnt - k + 1] - 1);
            ans %= mod;
        }
    }
    cout << ans;
}

    #include<bits/stdc++.h>
    #define ll long long
    using namespace std;

    ll mod=998244353;

    ll fact[500001]={0};
    void func(){
        fact[0]=1;
        for(ll i=1;i<200001;i++){
            fact[i]=((fact[i-1]%mod)*(i%mod))%mod;
        }
    }

    ll power(ll x,ll y){
        ll ans=1;
        while(y>0){
            if(y%2==1)
                ans=((ans%mod)*(x%mod))%mod;
            y/=2;
            x=((x%mod)*(x%mod))%mod;
        }
        return ans%mod;
    }

    ll ncr(ll n,ll r){
        if(n<r) return 0;
        ll temp1=fact[n];
        ll temp2=((fact[n-r]%mod)*(fact[r]%mod))%mod;
        temp2=power(temp2,mod-2);
        temp1=(temp1)*(temp2);
        temp1=temp1%mod;
        return temp1;
    }

    int main(){
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        func();
        ll n,k;
        cin>>n>>k;
        ll ans=0;
        for(int i=1;i<=n;i++){
            ans+=ncr((n/i) - 1,k-1 );
//            cout<<ncr((n/i)-1,k-1)<<endl;
            ans=ans%mod;
        }
        cout<<ans<<endl;
    }

#include<bits/stdc++.h>
using namespace std;

#define db(x) cout<<x<<'\n'
#define db1(x) cout<<#x<<"="<<x<<'\n'
#define db2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<'\n'
#define db3(x,y,z) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<'\n'
#define repi(i,n) for(int i=0;i<(n);++i)
//#define repA(i,a,n) for(int i=a;i<=(n);++i)
//#define repD(i,a,n) for(int i=a;i>=(n);--i)
#define ll long long int
#define endl '\n'
#define lld long long double
#define vi vector<int>
#define vl vector<ll>
#define vb vector<bool>
#define vvi vector<vector<int>  >
#define err(t) cout<<"Error : "<<t<<endl;
#define all(v) v.begin(),v.end()
#define mp make_pair
#define M 100000
#define MD 998244353
#define pb push_back
#define rep(i,a,b) for(ll i = a; i <= (b); i++)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vec(a) vector<a >
#define se second
#define fi first
#define inf 0xffffffff
#define inchar getchar_unlocked
#define outchar(x) putchar_unlocked(x)
//template <typename T>
//using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll binpow(ll a,ll b){	if(a==0) return 0; if(b==0) return 1;ll ans=1;while(b>0){if(b&1) {ans=ans*a;ans%=MD;} a=a*a;a%=MD; b=b>>1;}	return ans;}

vl per(500010,1);

int32_t main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);cout.tie(NULL);
	// int n;cin>>n;
	// string s;cin>>s;
	rep(i,1,500000){
		per[i]*=i*per[i-1];
		per[i]%=MD;
	}
	//ll n;cin>>n; vl a(n); repi(i,n) cin>>a[i];
	int n,k;cin>>n>>k;
	if(n<k) cout<<0<<endl;
	else if(n==k) cout<<n<<endl;
	else{
		ll ans=0,t;
		for(int i=1;i<=n-k+1;++i){
			int z=n/i;
			if(z>=k){
				z--;
				if(z==0) continue;
				t=1;
				t*=per[z];
				t*=binpow(per[k-1],MD-2);
				t%=MD;
				t*=binpow(per[z-k+1],MD-2);
				t%=MD;
				ans+=t;
				ans%=MD;
			}

		}
		db(ans);
	}

	/*
	int test1;cin>>test1;while(test1--){

	 }
	 //*/
return 0;
}

#include<bits/stdc++.h>
#include <iostream>
using namespace std;

#define ll          long long long long
#define int         long long int
#define pb          push_back
#define endl        "\n"
#define sp          " "
#define mp          make_pair
#define sz(x)       (int)x.size()
#define all(x)      x.begin(),x.end()
#define forn(i,a,b)      for(int i=a;i<b;i++)
#define hell        1000000007
#define dec(n)  std::cout << std::fixed;std::cout << std::setprecision(n);
#define helll      1073741824
# define PI 3.14159265358979323846
# define bc 998244353

bool cmp(int x,int y)
{
    return x>y;
}

int min(int a,int b)
{
    if(a>=b)
    return b;
    else
    return a;
}

int max(int a,int b)
{
    if(a>=b)
    return a;
    else
    return b;
}

int ndig(int n)
{
    int l=0;
    while(n>0)
    {
        n/=10;
        l++;
    }
    return l;
}

bool isprime(int n)
{
      if (n <= 1) return false;
      if (n <= 3) return true;
      if (n % 2 == 0 || n % 3 == 0) return false;
      for (int i = 5; i * i <= n; i = i + 6)
          if (n % i == 0 || n % (i + 2) == 0)
              return false;

      return true;
}

int gcd(int x,int y)
{
    int a,b,t,gcd,lcm;
     a = x;
     b = y;

     while (b != 0)
     {
     t = b;
     b = a % b;
     a = t;
     }

     gcd = a;
     return gcd;

}

int lcm(int x,int y)
{
    int a,b,t,gcd,lcm;
     a = x;
     b = y;

     while (b != 0)
     {
     t = b;
     b = a % b;
     a = t;
     }

     gcd = a;
     lcm = (x*y)/gcd;
     return lcm;
}
int cntdiv(int n)
{
    int cnt = 0;
    for (int i = 1; i <= sqrt(n); i++) {
        if (n % i == 0)
        {
            if (n / i == i)
                cnt++;
            else
                cnt = cnt + 2;
        }
    }
    return cnt;
}

const int N=500005;
int fact[N];

void prec()
{
  fact[0]=1;
  for(int i=1;i<N;i++)
  {
    fact[i]=((i%bc)*(fact[i-1]%bc))%bc;
    fact[i]%=bc;
  }
}
int facto(int x,int y)
{
  if(y>x)
    return 0;
  else
  {
    int a,b,c;
    a=fact[x];
    b=fact[x-y];
    c=fact[y];
    int d;
    d=(b*c)%bc;
    return (a/d)%bc;
  }
}
void solve()
{

int n,k;
cin>>n>>k;
int d;
int ans=0;
prec();
for(int i=1;i<=n;i++)
{
  d=n/i;
  ans+=facto(d-1,k-1);
  ans%=bc;
  if(facto(d-1,k-1)==0)
    break;
}
cout<<ans<<'\n';

}

signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("INPUT.txt","r",stdin);
    freopen("OUTPUT.txt","w",stdout);
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int TEST=1;
    //cin>>TEST;
    while(TEST--)
    {
        solve();
    }
    return 0;

}

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
const ll MOD = 998244353;

ll binpow(ll a, ll n) {
    ll r = 1;
    while (n) {
        if (n % 2 == 0) {
            a = (a * a) % MOD;
            n /= 2;
        } else {
            r = (r * a) % MOD;
            --n;
        }
    }
    return r;
}

ll inv(ll a) {
    return binpow(a, MOD - 2);
}

void solve() {
    ll n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n << endl;
        return;
    }
    if (n < k) {
        cout << 0 << endl;
        return;
    }
    vector<ll> fact(n + 1);
    fact[0] = 1;
    for (ll i = 1; i <= n; ++i) {
        fact[i] = (fact[i - 1] * i) % MOD;
    }
    auto combinations = [&](ll n, ll k) {
        ll r = (((fact[n] * inv(fact[k])) % MOD) * inv(fact[n - k])) % MOD;
        //cout << "combinations(" << n << ", " << k << ") = " << r << endl;
        return r;
    };
    ll ans = 0;
    for (ll mn = 1; mn <= n - k; ++mn) {
        if (n / mn >= k) {
            ans += combinations((n - mn) / mn, k - 1);
            ans %= MOD;
        }
    }
    cout << ans << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    solve();

    return 0;
}

#include <bits/stdc++.h>
#include<string.h>
#include <algorithm>
#include<math.h>
#include<vector>
#include <queue>
#include <deque>
#define ll long long
#define ld long double
#define M 1000000007
#define MM 998244353
using namespace std;

ll prck(ll n)
{
    ll f=1;
    if(n==1)
        f=0;
    else if(n==2)
        f=1;
    else if(n%2==0)
        f=0;
    else
    {
        ll i;
        for(i=3;(i*i<=n) && (f==1);i+=2)
        {
            if(n%i==0)
                f=0;
        }
    }
    return f;
}

ll nCr(ll n,ll r)
{
    ll i,res = 1;
    if (r>n-r)
        r=n-r;
    for(i=0;i<r;++i)
    {
        res*=(n-i);
        res/=(i+1);
    }
    return res;
}

ll gcd(ll a, ll b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}

ll btod(string n)
{
    ll lg=n.length();
    ll i,val=0,bs=1;
    for(i=lg-1;i>=0;i--)
    {
        if(n[i]=='1')
        {
            val+=bs;
        }
        bs*=2;
    }
    return val;
}

ll ston(string s)
{
    ll val=0,bs=1;
    ll sl=s.length();
    sl--;
    while(sl>=0)
    {
        val+=((s[sl]-48)*bs);
        bs*=10;
        sl--;
    }
    return val;
}

ll nCrModpDP(ll n, ll r, ll p)
{
    ll i,j,C[r+1];
    memset(C, 0, sizeof(C));
    C[0] = 1;
    for (i=1;i<=n;i++)
    {
        for(j=min(i,r);j>0;j--)
        {
            C[j] = (C[j]+C[j-1])%p;
        }
    }
    return C[r];
}
ll nCrModpLucas(ll n,ll r,ll p)
{
   if (r==0)
      return 1;
   ll ni = n%p, ri = r%p;
   return (nCrModpLucas(n/p, r/p, p) *
           nCrModpDP(ni, ri, p)) % p;
}

//(x^y)%p
ll pwr(ll x,ll y,ll p)
{
    ll res=1;
    x = x % p;
    while(y>0)
    {
        if (y & 1)
            res = (res*x) % p;
        y = y>>1;
        x = (x*x) % p;
    }
    return res;
}
//for bigger data
/*ll mul_mod(ll a, ll b, ll mod)
{
    ll res = 1;
    a=a%mod;
    while(b)
    {
        if(b & 1)
            res = ((__int128)res * a) % mod;
        a = ((__int128)a * a) % mod;

        b >>= 1;
    }
    return res;
}*/

ll modInverse(ll n,ll p)
{
    return pwr(n, p-2, p);
}

ll nCrModPFermat(ll n, ll r, ll p,ll fac[])
{
   if (r==0)
      return 1;

    return (fac[n]* modInverse(fac[r], p) % p *
            modInverse(fac[n-r], p) % p) % p;
}

/*ll fac[n+1];
        fac[0] = 1;
        ll i;
        for (i=1 ; i<=n; i++)
            fac[i] = fac[i-1]*i%M;*/

/*ll nPr(ll n,ll r,ll m,ll fac[])
{
    ll q=fac[n];
    r=(fac[r])%m;
    return (q*pow(r,m-2))%m;
}*/

// ll power(int x, unsigned int y)
// {
//     int temp;
//     if( y == 0)
//         return 1;
//     temp = power(x, y/2);
//     if (y%2 == 0)
//         return temp*temp;
//     else
//         return x*temp*temp;
// }

//Zeller's Congruence
int calcDate(int date,int month,int year)
{
    if(month==1)
    {
        month=13;
        year--;
    }
    if(month==2)
    {
        month=14;
        year--;
    }
    int q=date,m=month,k=year%100,j=year/100;
    int day = q + (13*(m+1))/5 + k + (k/4) + (j/4) + 5*j;
    day=day%7;
    return day;
}

vector<vector<ll>> matmul(vector<vector<ll>> a,vector<vector<ll>> b)
{
    ll k=a.size();
    vector<vector<ll>> c(k,vector<ll>(k));
    ll i,j,l;
    for(i=0;i<k;i++)
    {
        for(j=0;j<k;j++)
        {
            for(l=0;l<k;l++)
            {
                c[i][j]=(c[i][j]+a[i][l]*b[l][j])%M; //%Mo only if req.
            }
        }
    }
    return c;
}

vector<vector<ll>> matexp(vector<vector<ll>> a,ll p)
{
    if(p==1)return a;
    if(p&1)return matmul(a,matexp(a,p-1));
    vector<vector<ll>> x= matexp(a,p/2);
    return matmul(x,x);
}

//linear recurrence
//find Fn
ll linrec(ll n,ll k,vector<ll> a,vector<ll> b)
{
    if(n==0)return 0;
    if(n<=k)return a[n-1];
    ll i,j;
    vector<ll> F1(k+1);
    for(i=1;i<=k;i++)F1[i]=a[i-1];
    vector<vector<ll>> T(k+1,vector<ll>(k+1));
    for(i=1;i<=k;i++)
    {
        for(j=1;j<=k;j++)
        {
            if(i<k)
            {
                if(j==i+1)
                    T[i][j]=1;
                else T[i][j]=0;
                continue;
            }
            T[i][j]=b[k-j];
        }
    }

    T=matexp(T,n-1);
    ll res=0;
    for(i=1;i<=k;i++)
    {
        res+=(T[1][i]*F1[i])%M;
    }
    return res%M;
}

/*primefactors[a]=primefactors[a/primediviser[a]]+1*/
/*
    ll N=5000000+200;
    ll p[N]={},d[N],i,j;
    for(i=2;i<N;i++)
    {
        if(p[i]!=0)continue;
        for(j=i;j<N;j+=i)
        {
            if(p[j]==0)p[j]=i;
        }
    }
    d[1] = 0;
    for(i=2;i<N;i++)d[i]=1+d[i/p[i]];
    for(i=2;i<N;i++)d[i]+=d[i-1];
*/

ll modexp(ll x, ll n)
{
    if (n == 0)return 1;
    else if (n % 2 == 0)
    {
        return modexp((x * x) % M, n / 2);
    }
    else
    {
        return (x * modexp((x * x) % M, (n - 1) / 2) % M);
    }
}

ll getFractionModulo(ll a, ll b)
{
    ll c = gcd(a, b);
    a = a / c;
    b = b / c;
    ll d = modexp(b, M - 2);
    ll ans = ((a % M) * (d % M)) % M;
    return ans;
}

void dfs(ll x,ll par,ll vis[],vector<ll> adj[],ll in[],ll low[],ll ans[])
{
    vis[x]=1;
    ll children=0;
    for(ll y: adj[x])
    {
        if(y==par)continue;
        if(vis[y])
        {
            low[x]=min(low[x],in[y]);
        }
        else
        {
            dfs(y,x,vis,adj,in,low,ans);
            low[x]=min(low[x],low[y]);
            if(low[y]>=in[x] && par!=-1)
            {
                ans[x]=1;
            }
            children++;
        }
    }
    if(par==-1 && children>1)
    {
        ans[x]=1;
    }
}

void bfs(pair<ll,ll> strt,ll &flg)
{
    queue<pair<ll,ll>> q;
    q.push(strt);
    //vis[][]=1
    while(!q.empty() && flg==0)
    {
        pair<ll,ll> cur=q.front();
        q.pop();
    }
}

void addSelf(ll &a,ll b)
{
    a+=b;
    while(a>=M)a-=M;
}

void subSelf(ll &a,ll b)
{
    a-=b;
    while(a<0)a+=M;
}

struct sr{
    ll val,ind;
};

bool cmp(struct sr a,struct sr b)
{
    return a.val<b.val;
}

ll f[200002];

ll find(ll x)
{
    if(f[x]==x)return x;
    else return f[x]=find(f[x]);
}

bool connected(ll a,ll b)
{
    a=find(a);
    b=find(b);
    if(a==b)return 1;
    f[a]=b;
    return 0;
}

int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    /*ll t,w;
    cin>>t;
    w=0;
    while(w<t)
    {*/
        //cout<<"Case #"<<w+1<<": ";

        ll n,k,i,j;
        cin>>n>>k;
        ll fac[n+1];
        fac[0] = 1;
        for (i=1 ; i<=n; i++)
            fac[i] = fac[i-1]*i%MM;
        ll ans=0;
        for(i=1;i<=n;i++)
        {
            ans=(ans+nCrModPFermat((n/i)-1,k-1,MM,fac))%MM;
        }
        cout<<ans<<"\n";
        /*w++;
    }*/
    return 0;
}

#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>

#define INF 1000000021
#define MOD 998244353
#define pb push_back
#define sqr(a) (a)*(a)
#define M(a, b) make_pair(a,b)
#define T(a, b, c) make_pair(a, make_pair(b, c))
#define F first
#define S second
#define all(x) (x.begin(), x.end())
#define deb(x) cerr << #x << " = " << x << '\n'
#define N 222222

using namespace std;
//using namespace __gnu_pbds;

typedef long double ld;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

const ld pi = 2 * acos(0.0);
template<class T> bool umin(T& a, T b){if(a>b){a=b;return 1;}return 0;}
template<class T> bool umax(T& a, T b){if(a<b){a=b;return 1;}return 0;}
template<class T, class TT> bool pal(T a, TT n){int k=0;for(int i=0;i<=n/2;i++){if(a[i]!=a[n-i-1]){k=1;break;}}return k?0:1;}

//int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};

ll bn(ll a, ll n)
{
	ll r = 1;
	for(;n > 0; n >>= 1ll)
	{
		if(n & 1)
			r = (r * a) % MOD;
		a = (a * a) % MOD;
	}
	return r;
}
ll f[N*4];
ll cnk(ll n, ll k)
{
	if(n == k)
		return 1;
	if(n < k)
		return 0;
	ll q = f[n];
	ll p = (f[n-k]*f[k]) % MOD;
	ll o = (q*bn(p, MOD - 2)) % MOD;
	return o;
}

int main()
{
	f[0] = 1;
	for(ll i = 1; i <= N*3; i ++)
	{
		f[i] = (f[i - 1] * i) %MOD;
	}
	ll n, k;
	cin >> n >> k;
	if(k == 1)
	return cout << n,0;
	ll ans = 0;
	for(int i = 1; i <= k; i ++)
	{
		ll q = n/i-1;
		ans = (ans + cnk(q, k - 1)) % MOD;
	}
	cout << ans << '\n';

	getchar();
	getchar();
	return 0;
	//ios::sync_with_stdio(false);
	//cin.tie(0);
}

#include <bits/stdc++.h>
using namespace std;
long long ll,tt,i,j,b[1212145],c[1111456],d;
long long x,m,n,r,s,t,k,l,y,z;
string p,q ;
long long a[1234567];
vector<int> h,hh;
int main()
{
    cin >> n;
    for (i = 0; i <n; i ++)
        cin >> a[i];
    s = 0;
    for (z=1;z<=30; z++){
        x=-100;
        m=0;
        for (i = 0; i <n; i ++){
            if (a[i]>m+a[i]){
                m=a[i];
                x=a[i];
            }
            else {
                   m += a[i];
                   x=max(x,a[i]);
                }
            if (x > z){
                m=0;
                x=0;
            }
                s=max(s,m-x);
            }

        }
        cout <<s<<endl;
        return 0;
    }

#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#define ll long long
using namespace std;
ll mod = 998244353;

ll FACT[500001];

ll gcdExtended(ll a, ll b, ll *x, ll *y)
{
    // Base Case
    if (a == 0)
    {
        *x = 0;
        *y = 1;
        return b;
    }

    ll x1, y1; // To store results of recursive call
    ll gcd = gcdExtended(b%a, a, &x1, &y1);

    // Update x and y using results of
    // recursive call
    *x = y1 - (b/a) * x1;
    *y = x1;

    return gcd;
}

ll ccc(ll n, ll k){
    if(n < 1 || n < k) return 0;
    ll s = FACT[n];
    ll s1 = FACT[n - k], s2 = FACT[k];
    s1 = (s1 * s2) % mod;
    ll x, y;
    gcdExtended(s1, mod, &x, &y);
    x = x % mod;
    if(x < 0) x = x + mod;
    return (s * x) % mod;
    return 0;
}

int main() {
    ll n, k, sum = 0;
    cin >> n >> k;
    FACT[0] = 1;
    for(int i = 1; i <= n; i++){
        FACT[i] = FACT[i - 1] * i % mod;
    }
    for(int i = 1; i <= n; i++){
        sum = sum + ccc(n / i - 1, k - 1);
        sum = sum % mod;
    }
    cout << sum;
    return 0;
}

#include <bits/stdc++.h>
#define FOR(i,a,b) for(register int i=a;i<(b);++i)
#define ROF(i,a,b) for(register int i=a;i>=(b);--i)
using namespace std;
const int maxn = 500005;
const int p = 998244353;
const int inf = 2147483647;
const double pi=3.1415926576;
const long long INF = 9223372036854775807ll;
typedef long long ll;
int f[maxn],inv[maxn];
int qpow(ll a,ll b){
	ll ans=1;
	while(b){
		if(b&1ll)ans=ans*a%p;
		a=a*a%p;
		b>>=1ll;
	}
	return ans;
}
int cal(int a,int b){
	return (ll)f[a]*inv[b]%p*inv[a-b]%p;
}
int main(){
	int n,k;
	scanf("%d%d",&n,&k);
	f[1]=1;
	FOR(i,2,n+1)f[i]=1ll*f[i-1]*i%p;
	inv[n]=qpow(f[n],p-2);
	ROF(i,n-1,0)inv[i]=1ll*inv[i+1]*(i+1)%p;
	int ans=0;
	FOR(i,1,n+1){
		int cnt=n/i-1;
		if(cnt+1>=k){
			ans=(ans+cal(cnt,k-1))%p;
		}
	}
	printf("%d\n",ans);
}

/*
Just Another Source code by -
Ambuj
*/
#include<bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define vl vector<long>
#define vvi vector<vector<int>>
#define pii pair<int,int>
#define VP vector< pii >
#define MOD 1000000007
#define mp make_pair
#define pb push_back
#define rep(i,a,b) for(long (i) = (a); (i) < (b); (i)++)
#define all(v) (v).begin(),(v).end()
#define S(x) scanf("%d",&(x))
#define S2(x,y) scanf("%d%d",&(x),&(y))
#define SL(x) scanf("%lld",&(x))
#define SL2(x) scanf("%lld%lld",&(x),&(y))
#define P(x) printf("%d\n",(x))
#define FF first
#define SS second
#define DI int n;cin>>n;
using namespace std;
bool desc(int a,int b)
{
	return a> b;
}
ll power(ll x, ll y, ll p)
{
    ll res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
ll modInverse(ll n, ll p)
{
    return power(n, p-2, p);
}

// Returns nCr % p using Fermat's little
// theorem.
ll nCrModPFermat(ll n, ll r, ll p)
{
   // Base case
   if (r==0)
      return 1;

    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r
    ll fac[n+1];
    fac[0] = 1;
    for (ll i=1 ; i<=n; i++)
        fac[i] = fac[i-1]*i%p;

    return (fac[n]* modInverse(fac[r], p) % p *
            modInverse(fac[n-r], p) % p) % p;
}
int main(){
#ifndef ONLINE_JUDGE
freopen("/home/ambuj/.config/sublime-text-3/Packages/User/input.txt","r",stdin);
freopen ("/home/ambuj/.config/sublime-text-3/Packages/User/output.txt","w",stdout);
#endif
 ll n,k;
 cin>>n>>k;
 if(k>n){cout<<0<<endl;}

ll ans=nCrModPFermat(n-1,k-1,998244353);
rep(i,2,n-1)
{
	if(i*k<n){
	 ll mul=n/i;
	 ans+=nCrModPFermat(mul-1,k-1,998244353);
	 ans%=998244353;

	}else
	{
		//cout<<ans<<endl;
		break;;
	}
}

cout<<ans<<endl;
return 0;
}

#include <bits/stdc++.h>

#define int int64_t
#define pb push_back
#define Start_time clock_t startTime = clock();
#define End_time clock_t endTime = clock(),clockTicksTaken = endTime - startTime;double t = clockTicksTaken / (double) CLOCKS_PER_SEC;cout<<sp(t)<<endl;
#define ibswsct() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define gcd __gcd
#define s second
#define f first
#define sp(x) setprecision(13) << fixed << x

using namespace std;

typedef pair<int,int> pii ;
typedef pair<pair<int,int>,int> pii_i ;
typedef pair<int,pair<int,int> > pi_ii ;
typedef pair<pair<int,int>,pair<int,int> > piiii ;
// for order_of_key():
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>  ordered_set;

const int N = 5e5 + 10, mod = 998244353;
int n, k, fac[N];

int power(int x, int y = mod - 2){
    if(y == 0){
        return 1;
    }
    int ret = power(x, y >> 1);
    if(y & 1){
        return (((ret * ret) % mod) * x) % mod;
    }
    return (ret * ret) % mod;
}

int en(int x, int y){
    if(y < x){
        return 0;
    }
    if(x == 0){
        return 1;
    }
    int ret2 = (power(fac[x]) * power(fac[y - x])) % mod;
    ret2 *= fac[y];
    ret2 %= mod;
    return ret2;
}

int32_t main(){
	ibswsct();
	cin >> n >> k;
	if(k == 1){
        cout << n;
        return 0;
	}
	fac[0] = 1;
	for(int i=1;i<=5e5;i++){
        fac[i] = (fac[i - 1] * i) % mod;
	}
	int ans = 0;
	ans = en(k - 1, n / 2 - 1) + en(k - 1, n - 1);
	cout << ans;
}

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vl;
typedef vector<vector<long long>> vvl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<pair<int,int>> vii;
typedef vector<pair<long long,long long>> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
const int INF = INT_MAX;
const ll LL_INF = LLONG_MAX;
#define pb push_back
#define LOOP(x, a, b) for(int x = a; x < b; ++ x)
#define LOOPD(x, a, b) for(int x = a; x >= b; -- x)
#define mp make_pair
#define fi first
#define se second

const int MOD = 998244353;

int plus_mod(int a , int b){
	ll x = (long long)a + b;
	if(x<-1*MOD)x += 2*MOD;
	else if(x<0)x += MOD;
	else if(x>=MOD) x -= MOD;
	return (int)x;
}
int minus_mod(int a,int b){
	int x = a-b;
	if(x<-1*MOD)x += 2*MOD;
	else if(x<0)x += MOD;
	else if(x>=MOD) x -= MOD;
	return x;
}
int multiply(int a,int b){
	ll x = ((long long)a*b)%MOD;
	if(x<0) x += MOD;
	return (int)x;
}

void print_vector(vi& v){
	for(int i:v)cout<<i<<" ";
	cout<<'\n';
}
void print_array(int a[],int s,int e){
	LOOP(i,s,e)cout<<a[i]<<" ";
	cout<<'\n';
}

const int MAXN = 500005;
int inv[500005];
int fact[500005];
int ivf[500005];

void preprocess(){
	inv[1]=1;
	ivf[1] = 1;
	ivf[0] = 1;
	fact[0]=fact[1]=1;
	LOOP(i,2,MAXN){
		inv[i] = (MOD-((long long)(MOD/i)*inv[MOD%i])%MOD)%MOD;
		fact[i] = multiply(i,fact[i-1]);
		ivf[i] = multiply(inv[i],ivf[i-1]);
	}

}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int T;
	//cin>>T;
	T = 1;
	while(T--){

		int n,k;
		preprocess();
		cin>>n>>k;
		int val = 1;
		LOOPD(i,n-1,n-k+1){
			val = multiply(val,i);
			val = multiply(val,inv[(n-1-i+1)]);
		}
		int ans=val;
		LOOP(i,2,MAXN){
			int val = max(n/i-1,0);
			int x=0;
			if(val>=(k-1))x = multiply(fact[val],multiply(ivf[k-1],ivf[val-k+1]));
			ans = plus_mod(ans,x);

		}

		cout<<ans<<'\n';
	}
}

#include<bits/stdc++.h>

using namespace std;

const int N = 500001;
const int MOD = 998244353;

int fact[N];

int add(int x, int y) {
  x += y;
  while (x >= MOD)
    x -= MOD;
  while (x<0)
    x += MOD;
  return x;
}

int mul(int x, int y) {
  return (x * 1ll * y) % MOD;
}
void calculate_fact() {
  fact[0] = 1;
  fact[1] = 1;
  for (int i = 2; i < N; i++)
  {
    fact[i] = mul(i,fact[i - 1]);
  }
}

int binpow(int x, int y)
{
	int z = 1;
	while(y > 0)
	{
		if(y % 2 == 1)
			z = mul(z, x);
		x = mul(x, x);
		y /= 2;
	}
	return z;
}

int inv(int x)
{
	return binpow(x, MOD - 2);
}

int divide(int x, int y) {
  return mul(x, inv(y));
}

int calculate_combinations(int select_from, int to_select) {

  return divide(fact[select_from], mul(fact[select_from-to_select], fact[to_select]));
}

int main() {
  int n, k;
  cin >> n;
  cin >> k;
  calculate_fact();
  if (k > n)
  {
    cout << 0 << "\n";
  }
  int total = 0;
  int looper = floor(n * 1.0 / k);
  for (int i = 1; i <= looper; i++)
  {

    int select_from = floor(n * 1.0 / i) - 1;
    int to_select = k - 1;
    total = add(total, calculate_combinations(select_from, to_select)) ;
  }
  cout << total << "\n";
}

/*
 *  Lang    : C++
 *  Author  : little_angel
 */

#include<iostream>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

#define int long long
#define oset tree < int , null_type , less<> , rb_tree_tag , tree_order_statistics_node_update >
const int mod = 998244353;

int power(int x, int y) {
    int res = 1;
    while (y) {
        if (y & 1)res = res * x % mod;
        x = x * x % mod;
        y >>= 1;
    }
    return res;
}

inline int inv(int x) {
    return power(x, mod - 2);
}

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

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int n, k;
    cin >> n >> k;
    if (n == k) {
        cout << 1 << endl;
        return 0;
    }
    if (n < k) {
        cout << 0 << endl;
        return 0;
    }

    vector<int> fact(500001);
    vector<int> rfact(500001);
    fact[0] = 1;
    for (int i = 1; i < 500001; ++i) fact[i] = fact[i - 1] * i % mod;
    rfact[500000] = inv(fact[500000]);
    for (int i = 499999; i >= 0; --i)rfact[i] = (i + 1) * rfact[i + 1] % mod;

    auto ncr = [&](int n, int r) -> int {
        if (n < r || n == 0)return 0;
        if (r == 0 || n == r)return 1;
        return fact[n] * rfact[r] % mod * rfact[n - r] % mod;
    };

    int ans = 0;
    for (int i = 1; i <= k; ++i) {
        int _n = n / i;
        ans = add(ans, ncr(_n - 1, k - 1));
    }

    cout << ans << endl;
}

//#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <map>
#include <cmath>
#include <iomanip>
#include <fstream>

using namespace std;

#define int long long
const int MX = 1e7;
int mod = 998244353;
int fast (int a, int n) {
    if (n == 0)
        return 1;
    if (n % 2 == 1)
        return (fast(a, n-1) * a)%mod;
    else {
        int b = fast(a, n/2);
        return (b * b) % mod;
    }
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n;
        exit(0);
    }
    int ans = 0;

    vector<int> two(MX, 1);
    for (int i = 1; i < MX; ++i) {
        two[i] = two[i - 1] * i;
        two[i] %= mod;
    }
    for (int i = 1; i <= n; ++i) {
        int cnt = n / i;
        if (cnt >= k) {
            cnt--;
            ans += two[cnt];
            ans %= mod;
            ans *= fast(two[k - 1], two[k - 2]);ans %= mod;
            ans *= fast(two[cnt - k + 1], two[cnt - k + 1] - 2);
            ans %= mod;
        }
    }
    cout << ans;
}

//Coded by Abhijay Mitra
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <numeric>
#include <vector>
#include <iterator>
#include <map>
#include <set>
#include <climits>
#include <queue>
#include <iomanip>
#include <cmath>
#include <stack>
#include <cctype>
#include <bitset>
// #include <bits/stdc++.h>
#define double long double
#define int long long int
#define ll int
#define ibs ios_base::sync_with_stdio(false)
#define cti cin.tie(0)
#define bp __builtin_popcount
#define pb push_back
#define res(vector) v.resize(unique(v.begin(), v.end()) - v.begin());
#define timer cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
using namespace std;
const int N=2e6+10;
const int inf = /*0x3f3f3f3f*/1e9+10;
const ll M = 998244353 ; // Mulo
// const int M = 1e9+7 ; // Mulo
const double Pi = 3.14159265;
#define F first
#define S second
int n,k,ans;
int binomialCoeffUtil(int n, int k, int** dp)
{
    // If value in lookup table then return
    if (dp[n][k] != -1) //
        return dp[n][k];

    // store value in a table before return
    if (k == 0) {
        dp[n][k] = 1;
        return dp[n][k];
    }

    // store value in table before return
    if (k == n) {
        dp[n][k] = 1;
        return dp[n][k];
    }

    // save value in lookup table before return
    dp[n][k] = binomialCoeffUtil(n - 1, k - 1, dp) +
               binomialCoeffUtil(n - 1, k, dp);
    return dp[n][k];
}

int binomialCoeff(int n, int k)
{
    if(k>n)return 0;
    int** dp; // make a temporary lookup table
    dp = new int*[n + 1];

    // loop to create table dynamically
    for (int i = 0; i < (n + 1); i++) {
        dp[i] = new int[k + 1];
    }

    // nested loop to initialise the table with -1
    for (int i = 0; i < (n + 1); i++) {
        for (int j = 0; j < (k + 1); j++) {
            dp[i][j] = -1;
        }
    }

    return binomialCoeffUtil(n, k, dp);
}
ll powM(ll b, int p) {
  ll r=1;
  for(; p; b=b*b%M, p/=2)
    if(p&1)
      r=r*b%M;
  return r;
}
long long C(long long n,long long r)
{
    long long N=1,R=1;
    if(k>n)return 0;
    for(long long i=1;i<=n;i++) N=N*i%M;
    for(long long i=1;i<=r;i++) R=R*i%M;
    for(long long i=1;i<=n-r;i++) R=R*i%M;
    return (N*powM(R,M-2))%M;
}
int add(int a,int b){
  return ((a%M)+(b%M))%M;
}
void solve(){
  cin>>n>>k;
  if(n<1000)for(int i=1;i<=n;i++){
    ans=add(ans,(binomialCoeff((n/i)-1,k-1)));
  }
  else
  for(int i=1;i<=n;i++){
    ans=add(ans,(C((n/i)-1,k-1)));
  }
  cout<<ans;
}
int32_t main()
{
  ibs;cti;
  solve()
  /*,cout<<"\n"*/;
  // cout<<"\n";
  int xx=0;
  // int t;cin>>t;while(t--){/*xx++;cout<<"Case "<<xx<<":\n"*/;solve();/*cout<<"\n";*/}
  return 0;
}

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<iomanip>
#include<string>
#include<ctime>
#include<list>
#include<bitset>
#define pb push_back
#define input_fast std::ios::sync_with_stdio(false);std::cin.tie(0)
#define local freopen("in.text","r",stdin)
#define pi acos(-1)
#define int long long
typedef long long ll;
using namespace std;

template<class T> bool read(T & ret)//ll,int,double,float,+/-
{
	char c;int sgn;T bit=0.1;if(c=getchar(),c==EOF) return 0;while(c!='-' && c!='.' && (c<'0' || c>'9')) c=getchar();sgn=(c=='-')?-1:1;ret=(c=='-')?0:(c-'0');while(c=getchar(),c>='0' && c<='9') ret=ret*10+(c-'0');if(c==' '||c=='\n') {ret*=sgn;return 1;}while(c=getchar(),c>='0' && c<='9') ret+=(c-'0')*bit,bit/=10;ret*=sgn;return 1;
}
int n,k;
int jc[500010];
int inv[500010];
ll qp(ll a,ll b)
{
	ll res=1;
	while(b)
	{
		if(b&1) res=res*a%998244353;
		a=a*a%998244353;
		b>>=1;
	}
	return res;
}
ll C(int i,int j){
		if(i==0&&j==0) return 1;
		if(j==0) return i;
		return 1ll*jc[i]*inv[j]%998244353*inv[i-j]%998244353;
	}
signed main(){
	cin>>n>>k;
	ll res=0;
	jc[0]=1;
	for(int i=1;i<=n;++i) jc[i]=1ll*i*jc[i-1]%998244353;
	inv[n]=qp(jc[n],998244353-2);
	for(int i=n-1;i>=0;--i)  inv[i]=1ll*inv[i+1]*(i+1)%998244353;

	for(int i=1;i<=n;i++) inv[i]=qp(jc[i],998244351);

	for(int i=1;i<=n;i++)
	{
		int now=n/i;
		if(now>=k){
			res=(res+C(now-1,k-1))%998244353
			;
	}
	}
	cout<<res<<endl;
	return 0;
}

#include<bits/stdc++.h>
using namespace std;

#define ll       long long
#define ull      unsigned ll
#define pii      pair<int, int>
#define pll      pair<ll, ll>
#define mp       make_pair
#define ff       first
#define ss       second
#define sz(x)    (int) x.size()
#define all(v)   v.begin(), v.end()

template <typename T> inline void smin(T &a, T b) {a = a < b ? a : b;}
template <typename T> inline void smax(T &a, T b) {a = a > b ? a : b;}

#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {cout << endl;}
template<typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) {
    cerr << *it << " = " << a << ", ";
    err(++it, args...);
}

template <typename T> inline void Int(T &n) {
    n = 0; int f = 1; register int ch = getchar();
    for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
    for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
    n = n * f;
}

template <typename T, typename TT> inline void Int(T &n, TT &m) { Int(n); Int(m); }
template <typename T, typename TT, typename TTT> inline void Int(T &n, TT &m, TTT &l) { Int(n, m); Int(l); }

const int mod = (int) 998244353;

inline int add(int a, int b) {a += b; return a >= mod ? a - mod : a;}
inline int sub(int a, int b) {a -= b; return a < 0 ? a + mod : a;}
inline int mul(int a, int b) {return (ll) a * b % mod;}

const int inf = (int) 2e9 + 5;
const ll  Inf = (ll) 2e18 + 5;
const int N   = (int) 2e5 + 5;

int bigmod(int a, int b) {
	if(!b) return 1;
	int x = bigmod(a, b / 2);
	x = mul(x, x);
	if(b & 1) x = mul(x, a);
	return x;
}

int solve() {
    int n, k; Int(n, k);
    if(n < k) return printf("0\n");
    printf("%d\n", bigmod(2, n - k));
    return 0;
}

int main() {
    //ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int test = 1, tc = 0;
    //Int(test);
    //cin >> test;
    while (test--) {
        //printf("Case %d: ", ++tc);
        solve();
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define FIO ios_base::sync_with_stdio (false) ;cin.tie(NULL);
#define tc  int t;cin>>t;for(int i=0;i<t;i++)
#define ll long long int
#define forn(i,n) for(int i=0;i<n;i++)
#define forn1(i,a,b) for(int i=a;i<=b;i++)
#define pb push_back
#define um(a,b) unordered_map<a,b>
#define vv(a) vector<a>
#define pp(a,b) pair<a,b>
#define mod 998244353
#define imax 1000000
ll power(ll a,ll b){
  ll ans=1;
  while(b>0){
    if(b&1){
        ans=ans*a;
        ans%=mod;
    }
    a=a*a;
    b=b/2;
    a%=mod;
  }
  return ans;
}
ll arr[imax];
void help(){
    arr[0]=1;
    for(int i=1;i<imax;i++){
        arr[i]=arr[i]*i;
        arr[i]%=mod;
    }
}
// Function to find the nCr
ll printNcR(ll n, ll r)
{
    ll a=arr[n];
    ll b=arr[r];
    ll c=arr[n-r];
    ll temp=b*c;
    temp=temp%mod;
    ll temp2=power(temp,mod-2);
    ll ans=a*temp2;
    ans%=mod;
    return ans;
}

int main(){
  help();
    ll n,k;
  cin>>n>>k;
  ll ans=0;
  forn1(i,1,n){
      ll check=n/i;
      if(check>=k){
        ll  temp=printNcR(check-1,k-1);
        ans+=temp;
        ans%=mod;
      }
  }
  cout<<ans<<endl;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N=5e5;
ll mod=998244353;
ll fac[N];
ll power(ll x,ll n,ll p)
{
	if(n==0)
	return 1;
	ll y=power(x,n/2,p);
	y=(y*y)%mod;
	if(n&1)
	y=(y*x)%mod;
	return y;
}
ll modInverse(ll n, ll p)
{
    return power(n, p-2, p);
}
ll ncr(ll n, ll r, ll p)
{
   if(n<r)
   return 0;
   if (r==0)
      return 1;
   return (fac[n]* modInverse(fac[r], p) % p *  modInverse(fac[n-r], p) % p) % p;
}

int main()
{
	fac[0]=1;
	for(int i=1;i<N;i++)
	{
		fac[i]=(fac[i-1]*i)%mod;
	}
	ll n,k;
	cin>>n>>k;
	if(k>n)
	cout<<0<<endl;
	else if(k==1)
	cout<<n<<endl;
	else
	{

	ll ans=ncr(n-1,k-1,mod);
	for(int i=2;i<=n;i+=2)
	ans=(ans+ncr(i/2-1,k-1,mod))%mod;
	cout<<ans<<endl;
}
}

#include<bits/stdc++.h>

#define N 1000005

#define fi first

#define sc second

using namespace std;

typedef pair< int , int > II;

typedef pair< II , int > III;

typedef pair< II , II > IV;

int moder = 998244353;

int amount , pos;

int res = 0;

void solve()
{

    for(int i =1 ;i <= amount; i++){

        int new_amount = amount / i;

        res += (long long)(new_amount-1)*(new_amount-2) / 2;

        res %= moder;
    }

    printf("%d", res );
}

int main()
{
    //freopen("main.inp", "r", stdin );

    scanf("%d %d", &amount , &pos );

    solve();
}

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define ull unsigned long long
#define ui unsigned int
#define vi vector<int>
#define vll vector<ll>
#define pb push_back
#define ld long double
#define mp make_pair
#define pii pair<int,int>
#define mod 1000000007
#define mod1 998244353
#define rep(i,n) for(int i=0;i<n;i++)
/*
int nCrModpDP(int n, int r, int p)
{
    // The array C is going to store last row of
    // pascal triangle at the end. And last entry
    // of last row is nCr
    int C[r+1];
    memset(C, 0, sizeof(C));

    C[0] = 1; // Top row of Pascal Triangle

    // One by constructs remaining rows of Pascal
    // Triangle from top to bottom
    for (int i = 1; i <= n; i++)
    {
        // Fill entries of current row using previous
        // row values
        for (int j = min(i, r); j > 0; j--)

            // nCj = (n-1)Cj + (n-1)C(j-1);
            C[j] = (C[j] + C[j-1])%p;
    }
    return C[r];
}

// Lucas Theorem based function that returns nCr % p
// This function works like decimal to binary conversion
// recursive function.  First we compute last digits of
// n and r in base p, then recur for remaining digits
int nCrModpLucas(int n, int r, int p)
{
   // Base case
   if (r==0)
      return 1;

   // Compute last digits of n and r in base p
   int ni = n%p, ri = r%p;

   // Compute result for last digits computed above, and
   // for remaining digits.  Multiply the two results and
   // compute the result of multiplication in modulo p.
   return (nCrModpLucas(n/p, r/p, p) * // Last digits of n and r
           nCrModpDP(ni, ri, p)) % p;  // Remaining digits
}
*/
int power(int x, int y, int p)
{
    int res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
int modInverse(int n, int p)
{
    return power(n, p-2, p);
}

// Returns nCr % p using Fermat's little
// theorem.
int nCrModPFermat(int n, int r, int p)
{
   // Base case
   if (r==0)
      return 1;

    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r
    int fac[n+1];
    fac[0] = 1;
    for (int i=1 ; i<=n; i++)
        fac[i] = fac[i-1]*i%p;

    return (fac[n]* modInverse(fac[r], p) % p *
            modInverse(fac[n-r], p) % p) % p;
}
int main()
{
    int n,k;
    cin>>n>>k;
    if(n<k)
    cout<<0<<endl;
    else if(k==1)
    {
        cout<<n<<endl;
    }
    else
    {
        int a[k];
        int mark=0;
        for(int i=0;i<k;i++)
        {
            a[i]=n/(i+1);
            if(a[i]>=k)
            mark=i;
        }
        int sum=0;
        for(int i=0;i<=mark;i++)
        {
           // cout<<a[i]<<" ";
            sum=((sum%mod1)+(nCrModPFermat(a[i]-1, k-1, 998244353)))%mod1;
        }
        cout<<sum<<endl;
    }
}

/*
Author  : Yuvraj Raulji
College : DA-IICT,Gandhinagar
Country : India
*/
#include<bits/stdc++.h>
#define ll long long int
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define M 998244353

using namespace std;

const ll N = 2e5 + 5;
const ll mod = 1e9 + 7;
const int di[4]={-1,0,1,0};
const int dj[4]={0,-1,0,1};
const double pi=3.14159265358979323846;

ll gcd(ll a, ll b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}

ll po(ll x,ll n)
{
    if(n==0)
        return 1;
    else if(n%2 == 0)
        return po((x*x)%M,n/2);
    else
        return (x*po((x*x)%M,(n-1)/2))%M;

}

bool vis[N];
vector<ll> adj[N];
void dfs(ll x)
{
    vis[x] = true;
    for(int i=0;i<adj[x].size();i++)
    {
        if(!vis[adj[x][i]])
        {
            dfs(adj[x][i]);
        }
    }
}
ll dis[N],ct[N];
void bfs(ll x)
{
    queue<ll> q;
    q.push(x);
    dis[x]=1;
    ct[x]=1;
    while(!q.empty())
    {
        ll t=q.front();
        q.pop();
        for(auto i:adj[t])
        {
            if(!dis[i])
            {
                dis[i]=dis[t]+1;
                q.push(i);
                ct[i]=1;
            }
            else if(dis[i]==dis[t]+1)
                ct[i]++;
        }
    }
}
bool cmp(pair<ll,ll> a, pair<ll,ll> b)
{
    return a.ss<b.ss;
}
ll fact[N]={0};
ll ncr(ll n,ll r)
{
    ll d=fact[n];
    ll e=(fact[n-r]*fact[r])%M;
    d*=po(e,M-2);
    return d%M;
}

int32_t main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    fact[0]=1;
    for(int i=1;i<N;++i)
        fact[i]=(fact[i-1]*i)%M;

    ll n,k;
    cin>>n>>k;
    ll ans=0;
    for(int i=1;i<=n;++i)
    {
        ll x=n/i;
        if(x-1>=k-1)
            ans+=ncr(x-1,k-1);
        ans%=M;
    }
    cout << ans << '\n';

    return 0;
}

#include  <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = 5e5+10, mod = 998244353;

ll sum(ll x){
    return ((x*(x+1LL))/2LL)%mod;
}

typedef long long ll;

ll factorial[maxn];

ll exp(ll b, ll p){

    ll resp = 1;

    b = b % mod;

    while(p > 0){
        if(p & 1){
            resp = (resp * b)%mod;
        }
        p = p >> 1;
        b = (b * b)%mod;
    }

    return resp;
}

ll inverse(ll x){
    return exp(x, mod-2);
}

ll ncr(ll n, ll k) {
    return factorial[n] * inverse(factorial[k]) % mod * inverse(factorial[n - k]) % mod;
}

int main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

    ll n, k;

    cin >> n >> k;

    if(k == 1){
        cout << n << endl;
        return 0;
    }

    factorial[0] = 1LL;

    for(ll i=1; i<=n; i++){
        factorial[i] = (factorial[i - 1] * i) % mod;
    }

    long long ans = 0LL;

    for(ll i=1; i<=k; i++){
        ll div = n/i;

        div--;

        if(div >= k-1) ans = (ans + ncr(div, k-1))%mod;
    }

    cout << ans << endl;

	return 0;
}

#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#define ll long long
using namespace std;
ll mod = 998244353;

ll FACT[500001];

ll gcdExtended(ll a, ll b, ll *x, ll *y)
{
    // Base Case
    if (a == 0)
    {
        *x = 0;
        *y = 1;
        return b;
    }

    ll x1, y1; // To store results of recursive call
    ll gcd = gcdExtended(b%a, a, &x1, &y1);

    // Update x and y using results of
    // recursive call
    *x = y1 - (b/a) * x1;
    *y = x1;

    return gcd;
}

ll ccc(ll n, ll k){
    if(n < 1 || n < k) return 0;
    ll s = FACT[n];
    ll s1 = FACT[n - k], s2 = FACT[k];
    s1 = (s1 * s2) % mod;
    ll x, y;
    gcdExtended(s1, mod, &x, &y);
    x = x % mod;
    if(x < 0) x = x + mod;
    return (s * x) % mod;
    return 0;
}

int main() {
    ll n, k, sum = 0;
    cin >> n >> k;
    FACT[0] = 1;
    for(int i = 1; i <= n; i++){
        FACT[i] = FACT[i - 1] * i % mod;
    }
    for(int i = 1; i <= n; i++){
        sum = sum + ccc(n / i - 1, k - 1);
        sum = sum % mod;
    }
    cout << sum;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
long long arr[500009];
void doit(){
    arr[1]=1;
    arr[0]=1;
    for(long long  i=2;i<=500005;i++){
        arr[i]=(i*arr[i-1])%998244353;
    }
}
long long comb(long  a,long  b){
    return arr[a]/(arr[b]*arr[a-b]);
}
int main(){
    long long n,k;
    cin>>n>>k;
    doit();
    long long  a1;
    long long ans=0;
    for(long long a1=1;((n/a1)-1)>=(k-1);a1++){
        ans+=(comb(((n/a1)-1),k-1)%998244353);
    }
    cout<<ans;
}

/*
Author  : Yuvraj Raulji
College : DA-IICT,Gandhinagar
Country : India
*/
#include<bits/stdc++.h>
#define ll long long int
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define M 998244353

using namespace std;

const ll N = 2e5 + 5;
const ll mod = 1e9 + 7;
const int di[4]={-1,0,1,0};
const int dj[4]={0,-1,0,1};
const double pi=3.14159265358979323846;

ll gcd(ll a, ll b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}

ll po(ll x,ll n)
{
    if(n==0)
        return 1;
    else if(n%2 == 0)
        return po((x*x)%M,n/2);
    else
        return (x*po((x*x)%M,(n-1)/2))%M;

}

bool vis[N];
vector<ll> adj[N];
void dfs(ll x)
{
    vis[x] = true;
    for(int i=0;i<adj[x].size();i++)
    {
        if(!vis[adj[x][i]])
        {
            dfs(adj[x][i]);
        }
    }
}
ll dis[N],ct[N];
void bfs(ll x)
{
    queue<ll> q;
    q.push(x);
    dis[x]=1;
    ct[x]=1;
    while(!q.empty())
    {
        ll t=q.front();
        q.pop();
        for(auto i:adj[t])
        {
            if(!dis[i])
            {
                dis[i]=dis[t]+1;
                q.push(i);
                ct[i]=1;
            }
            else if(dis[i]==dis[t]+1)
                ct[i]++;
        }
    }
}
bool cmp(pair<ll,ll> a, pair<ll,ll> b)
{
    return a.ss<b.ss;
}
ll fact[N]={0};
ll ncr(ll n,ll r)
{
    ll d=fact[n];
    ll e=(fact[n-r]*fact[r])%M;
    d*=po(e,M-2);
    return d%M;
}

int32_t main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    fact[0]=1;
    for(int i=1;i<N;++i)
        fact[i]=(fact[i-1]*i)%M;

    ll n,k;
    cin>>n>>k;
    if(k==1)
    {
        cout << n << '\n';
        return 0;
    }
    ll ans=0;
    for(int i=1;i<=n;++i)
    {
        ll x=n/i;
        if(x-1>=k-1)
            ans+=ncr(x-1,k-1);
        ans%=M;
    }
    cout << ans << '\n';

    return 0;
}

/*
500000 1
*/
#include <bits/stdc++.h>
using namespace std;
using ll = long long; using ld = long double; using pii = pair<int, int>; const int N = 5e5 + 5, M = 998244353, INF = 0x3f3f3f3f; void Main();
void dprint() { cerr << '\n'; } template<typename T, typename ...U> void dprint(const T& x, const U& ...y) { ((sizeof ...(y) == 0) ? (cerr << x) : (cerr << x << ' ')); dprint(y...); } template<typename T> void dprint(const T& a, int l, int r, char c) { for (int i = l; i <= r; ++i) { cerr << a[i]; if (i == r) cerr << '\n'; else cerr << c;  } } template<typename ...U> void debug(const U& ...y) { cerr << "debug: "; dprint(y...); };
void print() { cout << '\n'; } template<typename T, typename ...U> void print(const T& x, const U& ...y) { ((sizeof ...(y) == 0) ? (cout << x) : (cout << x << ' ')); print(y...); } template<typename T> void print(const T& a, int l, int r, char c) { for (int i = l; i <= r; ++i) { cout << a[i]; if (i == r) cout << '\n'; else cout << c;  } }
void input() {} template<typename T, typename ...U> void input(T& x, U& ...y) { cin >> x; input(y...); } template<typename T> void input(T& a, int l, int r, bool f) { for (int i = l; i <= r; ++i) cin >> a[i]; }
template<typename T> void Max(T &a, T b) { a < b ? a = b : 1; } template<typename T> void Min(T& a, T b) { a > b ? a = b : 1; } template<typename T> void Add(T& a, T b) { a += b, a > M ? a -= M : 1, a < 0 ? a += M : 1; } template<typename T> void Mul(T &a, T b) { a = a * b % M; } template<typename T> T Mod(const T a) { return (a % M + M) % M; }
int main(int argc, char **argv) {
  ios::sync_with_stdio(0), cin.tie(0); /* cout << setprecision(10) << fixed; */
  #ifdef Zmm
  freopen((string(*(argv)).substr(2, string(*(argv)).size() - 6) + string(".cpp")).c_str(), "r", stdin); string x; cin >> x;
  #endif
  /* fread(BUF1, 1, SIZE, stdin); */ Main(); /* fwrite(BUF2, 1, buf2 - BUF2, stdout); */
}
ll qpow(ll a, ll b) {
  ll ret = 1;
  while (b) {
    if (b & 1) ret = a * ret % M;
    a = a * a % M, b >>= 1;
  }
  return ret;
}
ll fact[N], finv[N];
void init(int n) {
  fact[1] = 1;
  for (int i = 2; i <= n; ++i) fact[i] = fact[i - 1] * i % M;
  finv[n] = qpow(fact[n], M - 2);
  for (int i = n - 1; i >= 1; --i) finv[i] = finv[i + 1] * (i + 1) % M;
}
ll C(ll n, ll m) {
  if (n < m) return 0;
  if (m == 0 || m == n) return 1;
  return fact[n] * finv[m] % M * finv[n - m] % M;
}
void Main() {
  int n, k;
  input(n, k);
  if (n < k) return print(0);
  if (k == 1) return print(1);
  init(n);
  ll ans = 0;
  for (int i = 1; i <= n - k + 1; ++i) {
    ll x = n / i;
    // if (x < k) break;
    Add(ans, C(x - 1, k - 1));
    // print(i, C(x - 1, k - 1), x - 1, k - 1);
    // if (i == 3) break;
  }
  print(ans);
}

#include<bits/stdc++.h>
using namespace std;

long long arr[500005]={0};
void func(long long n)
{
    for(long long int i=2;i<=n;i++)
    {
        arr[i]=(i*arr[i-1])%998244353;
    }
}

long long inv(long long k)
{
    long long x = 998244353-2;
    long long temp = 1;
    while(x>0)
    {
        if(x%2==1)
        {
            temp = (temp*k)%998244353;
        }
        k = (k*k)%998244353;
        x = x>>1;
    }
    return temp;
}

long long nck(long long n, long long k)
{
    if(n<k){return 0;}

    return (((n*inv(k))%998244353)*inv(n-k))%998244353;
}

int main()
{
    long long n,k;
    cin>>n>>k;
    func(n);

    long long ans=0;
    long long t;
    for (long long i=1;i<=n/k;i++)
    {
        t=n/i;
        ans = (ans+nck(t-1,k-1))%998244353;
    }

    cout<<ans<<endl;
}

#include<stdio.h>
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
#include<stack>
#include<math.h>
#include<string.h>
#include<string>
#include<queue>
#define MAX 500000
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;

const ll mod = 998244353;
ll fac[MAX + 9], inv[MAX + 9];
ll _pow(ll a, ll b) {
	ll ret = 1;
	while (b) {
		if (b & 1) ret = (ret * a) % mod;
		a = (a * a) % mod;
		b >>= 1;
	}
	return ret;
}
int main()
{
	fac[0] = 1;
	for (int i = 1; i <= MAX; i++) {
		fac[i] = (fac[i - 1] * i) % mod;
	}
	inv[MAX] = _pow(fac[MAX], mod - 2);
	for (int i = MAX - 1; i >= 0; i--) {
		inv[i] = (inv[i + 1] * (i + 1)) % mod;
	}
	ll n, k, ans = 0; scanf("%lld%lld", &n, &k);

	for (ll i = 1; i <= n; i++) {
		ans += (fac[n / i - 1] * inv[k - 1]) % mod;
		ans %= mod;
	}
	printf("%lld", ans);
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
const ll MOD = 998244353;

ll binpow(ll a, ll n) {
    ll r = 1;
    while (n) {
        if (n % 2 == 0) {
            a = (a * a) % MOD;
            n /= 2;
        } else {
            r = (r * a) % MOD;
            --n;
        }
    }
    return r;
}

ll inv(ll a) {
    return binpow(a, MOD - 2);
}

void solve() {
    ll n, k;
    cin >> n >> k;
    if (k == 1) {
        cout << n << endl;
        return;
    }
    if (n < k) {
        cout << 0 << endl;
        return;
    }
    vector<ll> fact(n + 1);
    fact[0] = 1;
    for (ll i = 1; i <= n; ++i) {
        fact[i] = (fact[i - 1] * i) % MOD;
    }
    auto combinations = [&](ll n, ll k) {
        ll r = (((fact[n] * inv(fact[k])) % MOD) * inv(fact[n - k])) % MOD;
        cout << "combinations(" << n << ", " << k << ") = " << r << endl;
        return r;
    };
    ll ans = 0;
    for (ll mn = 1; mn <= n - k; ++mn) {
        if ((n - mn) / mn >= k - 1) {
            ans += combinations((n - mn) / mn, k - 1);
            ans %= MOD;
        }
    }
    cout << ans << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    solve();

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define mod 998244353
int product[500001];
int modinverse(int a, int m)
{
    int m0 = m;
    int y = 0, x = 1;
    if (m == 1)
      return 0;
    while (a > 1)
    {
        int q = a / m;
        int t = m;
        m = a % m, a = t;
        t = y;
        y = x - q * y;
        x = t;
    }
    if (x < 0)
       x += m0;
    return x%mod;
}
int ncr(int n,int r)
{
    if(n<r || n<0 || r<0)
    return 0;
    int numerator,denominator;
    numerator = product[n];
    denominator = (product[r]*product[n-r])%mod;
    int ans=(numerator*modinverse(denominator,mod))%mod;
    return ans;
}
signed main()
{
    int n,k,i,ans=0;
    cin>>n>>k;
    product[0]=1;
    for(i=1;i<=500000;i++)
    {
        product[i]=product[i-1]*i;
        product[i]%=mod;
    }
    for(i=1;i<=k;i++)
    {
        int t=n/i;
        ans+=ncr(t-1,k-1);
        ans%=mod;
    }
    cout<<ans;
    return 0;
}

#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>

#define INF 1000000021
#define MOD 998244353
#define pb push_back
#define sqr(a) (a)*(a)
#define M(a, b) make_pair(a,b)
#define T(a, b, c) make_pair(a, make_pair(b, c))
#define F first
#define S second
#define all(x) (x.begin(), x.end())
#define deb(x) cerr << #x << " = " << x << '\n'
#define N 222222

using namespace std;
//using namespace __gnu_pbds;

typedef long double ld;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

const ld pi = 2 * acos(0.0);
template<class T> bool umin(T& a, T b){if(a>b){a=b;return 1;}return 0;}
template<class T> bool umax(T& a, T b){if(a<b){a=b;return 1;}return 0;}
template<class T, class TT> bool pal(T a, TT n){int k=0;for(int i=0;i<=n/2;i++){if(a[i]!=a[n-i-1]){k=1;break;}}return k?0:1;}

//int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};

ll bn(ll a, ll n)
{
	ll r = 1;
	for(;n > 0; n >>= 1ll)
	{
		if(n & 1)
			r = (r * a) % MOD;
		a = (a * a) % MOD;
	}
	return r;
}
ll f[N*4];
ll cnk(ll n, ll k)
{
	if(n < k)
		return 0;
	ll q = f[n];
	ll p = (f[n-k]*f[k]) % MOD;
	ll o = (q*bn(p, MOD - 2)) % MOD;
	return o;
}

int main()
{
	f[0] = 1;
	for(ll i = 1; i <= N*3; i ++)
	{
		f[i] = (f[i - 1] * i) %MOD;
	}
	ll n, k;
	cin >> n >> k;
	if(k == 1)
	return cout << n,0;
	ll ans = 0;
	for(int i = 1; i <= k; i ++)
	{
		ll q = n/i-1;
		ans = (ans + cnk(q, k - 1)) % MOD;
	}
	cout << ans << '\n';

	getchar();
	getchar();
	return 0;
	//ios::sync_with_stdio(false);
	//cin.tie(0);
}

#include <bits/stdc++.h>
#define lli  long long int
#define forr(i,a,n) for(i=a;i<n;i++)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define pb push_back
#define pi 3.1415926536
#define endl '\n'
#define mod 1000000007
#define mod1 998244353
#define mkp make_pair
#define N 100005
#define INF 1e18
// #define double long double
#define query cin>>q;while(q--)
#define couty cout<<"YES"<<endl
#define coutn cout<<"NO"<<endl
#define F first
#define S second

using namespace std;

lli fact(lli n){
    if(n==1 || n==0)
        return 1;
    return n*fact(n-1);
}

lli isPrime(lli n){
    if(n < 2)
        return 0;
    if(n < 4)
        return 1;
    if(n % 2 == 0 or n % 3 == 0)
        return 0;
    for(lli i = 5; i*i <= n; i += 6)
        if(n % i == 0 or n % (i+2) == 0)
            return 0;
    return 1;
}

lli modexpo(lli x,lli p){
    lli res = 1;
    x = x%mod;
    while(p){
        if(p%2)
            res = res * x;
        p >>= 1;
        x = x*x % mod;
        res %= mod;
    }
    return res;
}

lli binSearch(lli a[],lli l,lli h, lli x){
    lli c=-1;
    while(l<=h){
        lli m=(l+h)/2;
        if(a[m]>=x){
            c=m;
            h=m-1;
        }
        else l=m+1;
    }
    return c;
}

void pairsort(lli a[], lli b[], lli n){
    pair<lli, lli> pairt[n];
    for (lli i = 0; i < n; i++)
    {
        pairt[i].first = a[i];
        pairt[i].second = b[i];
    }
    sort(pairt, pairt + n);
    for (lli i = 0; i < n; i++)
    {
        a[i] = pairt[i].first;
        b[i] = pairt[i].second;
    }
}

void rev_pairsort(lli a[], lli b[], lli n){
    pair<lli, lli> pairt[n];
    for (lli i = 0; i < n; i++)
    {
        pairt[i].first = a[i];
        pairt[i].second = b[i];
    }
    sort(pairt, pairt + n);
    reverse(pairt, pairt + n);
    for (lli i = 0; i < n; i++)
    {
        a[i] = pairt[i].first;
        b[i] = pairt[i].second;
    }
}

lli nod(lli n){
    lli c=0;
    while(n>0){
        c++;
        n/=10;
    }
    return c;
}

lli sod(lli n){
    lli s=0;
    while(n>0){
        s+=n%10;
        n/=10;
    }
    return s;
}

lli mulmod(lli a, lli b, lli mod2)
{
    lli res = 0;
    a = a % mod2;
    while (b > 0)
    {
        if (b % 2 == 1)
            res = (res + a) % mod2;

        a = (a * 2) % mod2;
        b /= 2;
    }

    return res % mod;
}

string intToString(lli n){
    string s ="";
    while(n>0){
        s+=char(n%10+'0');
        n/=10;
    }
    reverse(s.begin(), s.end());
    return s;
}

int myComp(pair<lli, lli> p1, pair<lli, lli>p2){
    if(p1.second < p2.second || (p1.second == p2.second && p1.first < p2.first))
        return 1;
    return 0;
}

lli getFractionModulo(lli a, lli b, lli mod2)
{
    lli c = __gcd(a, b);

    a = a / c;
    b = b / c;

    // (b ^ m-2) % m
    lli d = modexpo(b, mod2 - 2);

    // Final answer
    lli ans = ((a % mod2) * (d % mod2)) % mod2;

    return ans;
}

lli binToNum(string s) {
    lli n = 0, i;
    forr(i,0,s.length()){
        n = 2*n + (s[i]-'0');
    }

    return n;
}

string strToBin(lli n) {
    string s = "";

    while (n > 0) {
        s += (n%2+ '0');
        n /= 2;
    }

    reverse(s.begin(), s.end());

    return s;
}

lli my_pow(lli a, lli b) {
    if (b == 0)
        return 1;
    lli x = my_pow(a, b/2);
    if (b%2)
        return a*x*x;
    else
        return x*x;
}

lli power(lli x, lli y, lli p)
{
    lli res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
lli modInverse(lli n, lli p)
{
    return power(n, p-2, p);
}

lli fac[500005];

lli nCrModPFermat(lli n, lli r, lli p)
{
   // Base case
   if (r==0)
      return 1;

    return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n-r], p) % p) % p;
}

int main(){
    IOS;
    lli n,t,p,q,r,m,k,i,j,f=0,g=0,h=1,sum=0,ans=0,l,x,y,total=0,d,minn=1e18,maxx=0,pos=0,epoch=1,cnt=0;

    cin>>n>>k;

    if (n < k){
        cout<<0;
        return 0;
    }

    if (k == 1 || k == n) {
        cout<<1;
        return 0;
    }

    fac[0] = 1;
    for (lli i = 1; i < 500005; i++)
        fac[i] = (fac[i-1]%mod1 * i%mod1) % mod1;

    m = 0;
    forr(i, 1, k){
        if (n/i < k)
            break;
        m += nCrModPFermat(n/i-1, k-1, mod1);
        m %= mod1;
    }

    cout<<m;

    return 0;
}

#include <bits/stdc++.h>
#define R register int
#define ll long long
using namespace std;
const ll P=998244353;
const int maxn=1e7+10;
ll frac[maxn];
void init()
{
	frac[0]=1;
	for(R i=1;i<=maxn;i++)frac[i]=frac[i-1]*i%P;
}
ll ksm(ll a,ll b)
{
	ll ans=1;
	a%=P;
	while(b)
	{
		if(b&1)ans=(ans*a)%P;
		b>>=1;
		a=(a*a)%P;
	}
	return ans;
}
ll inv(ll a)
{
	return ksm(a,P-2);
}
ll C(int n,int m)
{
    if(m>n)return 0;
    return frac[n]*inv(frac[m]*frac[n-m]%P);
}
int main()
{
	int t;
	scanf("%d",&t);
	init();
	while(t--)
	{
		int n,m;
		ll ans=0;
		scanf("%d%d",&n,&m);
		for(R i=1;i<n;i++)
		{
			int x=(n-1)/i-1,y=m-1;
			ans=(ans+C(x,y))%P;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

/*Author - Dhananjay Singh (@Dhananjay_049)*/
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
typedef long long ll;
typedef vector<ll> vl;		typedef vector<int> vi;
typedef vector<vl> vvl;	  	typedef vector<vi> vvi;
typedef pair<ll, ll> pll;	typedef pair<int, int> pii;
#define forn(i,n) for(int i=0;i<n;i++)
#define rforn(i,n) for(int i=n-1;i>=0;i--)
#define forne(i,n) for(int i=1;i<=n;i++)
#define forse(i,s,e) for(int i=s;i<e;i++)
#define rforse(i,s,e) for(int i=e-1;i>=s;i--)
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define MOD 1000000007
#define F first
#define S second
#define pb push_back
#define fill(a,x) memset(a,x,sizeof a);
#define trav(a,x) for(auto &a:x)
#define INF	ll(1e18)
#ifdef DHANANJAY_049
#include "../code-pieces/trace.h"
#else
#define trace(args...)
#endif
//ordered_set T; T.insert(val);*T.find_by_order(index);T.order_of_key(val);
//find_by_order(k): It returns to an iterator to the kth element (counting from zero)
//order_of_key(k) : It returns to the number of items that are strictly smaller than our item k
//Thus we can now solve the above problem easily i.e. count of elements between l and r can be found by:
//o_set.order_of_key(r+1) – o_set.order_of_key(l)
ll modpow(ll a, ll b, ll m = MOD) {
	a %= m; ll res = 1; while (b) {if (b & 1)res = res * a % m; a = a * a % m; b >>= 1;}
	return res;
}
ll bpow(ll a, ll b) {ll res = 1; while (b) {if (b & 1)res = res * a; a = a * a; b >>= 1;} return res;}
ll modinv(ll a) {return modpow(a, MOD - 2, MOD);}
void graph(vvi &adj, int m) {int x, y; forn(i, m) {cin >> x >> y; adj[x - 1].pb(y - 1); adj[y - 1].pb(x - 1);}}
 struct hash_pair {
    template <class T1, class T2>
    size_t operator()(const pair<T1, T2>& p) const
    {
        auto hash1 = hash<T1>{}(p.first);
        auto hash2 = hash<T2>{}(p.second);
        return hash1 ^ hash2;
    }
};
const int mxN = 2e5 + 5;
ll power(ll x, ll y, ll p)
{
    ll res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

// Returns n^(-1) mod p
ll modInverse(ll n, ll p)
{
    return power(n, p-2, p);
}
   ll fac[100001];
// Returns nCr % p using Fermat's little
// theorem.
ll nCrModPFermat(ll n, ll r, ll p)
{
   // Base case
   if (r==0)
      return 1;

    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r

    return (fac[n]* modInverse(fac[r], p) % p *
            modInverse(fac[n-r], p) % p) % p;
}

void solve(){
    ll p = 998244353;
    fac[0] = 1;
    for (int i=1 ; i<=100000; i++){
        fac[i] = fac[i-1]*i%p;}
    int n,k;
    cin>>n>>k;
    //cout<<n-1<<' '<<k-1<<' '<<p<<'\n';
    ll ans = n-1<k-1?0:nCrModPFermat(n-1,k-1,p);
    //cout<<ans<<'\n';
    forse(i,2,n){
        int z = (n/i)-1;
        if(z<k-1){continue;}
        ans+=nCrModPFermat(z,k-1,p);
        ans%=p;
    }
    cout<<ans;
}
int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
#ifdef DHANANJAY_049
	freopen("inp.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	freopen("err.txt", "w", stderr);
#endif
	int t = 1;
	//cin >> t;
	while (t--) {
		solve();
	}
}

#include <bits/stdc++.h>

using namespace std;

typedef long double ld;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;

#define pb push_back
#define F first
#define S second
#define ALL(v) v.begin(),v.end()
#define fast_cin() ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);

#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

const int mod = 998244353;
const ll inf = 5e18;
const int MAX = 5e5 + 100;

ll fact[MAX], inv[MAX];

ll mypow(ll a, ll m, ll p) {
	ll res = 1;
	a %= p;
	while(m > 0) {
		if(m & 1) {
			res = (res * a) % p;
		}
		m /= 2;
		a = (a * a) % p;
	}
	return res;
}

ll getInverse(ll a) {
	return mypow(a, mod - 2, mod);
}

void pre() {
	fact[0] = 1;
	inv[0] = getInverse(1);
	for(ll i = 1; i < MAX; i++) {
		fact[i] = (fact[i - 1] * i) % mod;
		inv[i] = getInverse(fact[i]);
	}
}
ll choose(ll n, ll r) {
    return (((fact[n] * inv[n - r]) % mod) * inv[r]) % mod;
}

int main() {
    pre();
    ll n, k; cin >> n >> k;
    if(k == 1) {
        cout << n << endl;
        return 0;
    }
    ll N = n - 1, K = k - 1;
    ll ans = 0;
    if(K >= 2) {
        for(ll nr = K - 1; nr <= N - 1; nr++) {
            ans += choose(nr - 1, K - 2) * (N - nr);
            ans %= mod;
        }
    } else if(K == 1) {
        ans = N;
    }
    trace(ans);
    for(ll i = 2; i <= N; i++) {
        N = n / i - 1, K = k - 1;
        if(N < K) {
            break;
        }
        if(K >= 2) {
            for(ll nr = K - 1; nr <= N - 1; nr++) {
                ans += choose(nr - 1, K - 2) * (N - nr);
                ans %= mod;
                trace(nr - 1, K - 2, ans);
            }
        } else if(K == 1) {
            ans += N;
        }
    }
    cout << (ans + mod) % mod << endl;
}

#include<bits/stdc++.h>
#define mod 998244353
#define ll long long
using namespace std;
int main (){
	ll n,k;
	cin>>n>>k;
	ll cnt=0,C[k+1][n+1];
	C[1][1]=1;
	for (int i=2;i<=k;i++)	C[i][1]=0;
	for (int i=2;i<=n;i++)
		for (int j=1;j<=k;j++){
			if (j==1) C[j][i]=i;
			else
				C[j][i]=(C[j-1][i-1]+C[j][i-1])%mod;
		}
	for (int i=1;i*k<=n;i++){
		ll tmp=n/i;
		cnt=(cnt+C[k-1][tmp-1])%mod;
	}
	cout<<cnt;
}

/*
* sto RainAir,Logey,Shq,HandwerSTD,Herself32,Zyque,MoveToEX,Liuzhe,uliahradri,Extmool orz
* 感谢真神们无私的教诲。
* 膜真神者处处阿克，只因大师们在他背后。
* 不膜真神者将违背真神的旨意，真神必将降下天谴，使其天天爆零
* 因此,我不由自主地膜拜真神们 orz。
*											——Payphone-X
*/
#include <algorithm>
#include <iostream>
#include <cstring>
#include <iomanip>
#include <cstdlib>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <cctype>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <map>
#include <set>

#define I inline
#define ll long long
#define pb push_back
#define MP make_pair
#define ull unsigned long long
#define PII pair<int , int>
#define PIL pair<int , long long>
#define PSL pair<string , long long>
#define PLL pair<long long , long long>
#define all(x) (x).begin() , (x).end()
#define copy(a , b) memcpy(a , b , sizeof(b))
#define clean(a , b) memset(a , b , sizeof(a))
#define rep(i , l , r) for (int i = (l); i <= (r); i ++)
#define per(i , r , l) for (int i = (r); i >= (l); i --)
#define PE(i , x) for(int i = head[x]; i; i = edge[i].last)
#define DEBUG(x) std :: cerr << #x << '=' << x << std :: endl

using namespace std;

const int N = 10001;
const int M = 100001;
const int HA = 998244353;
const int INF = 2147483647;
const long long INFL = 9223372036854775807;

#define int ll

int n , k;
int inv[M * 10] , fac[M * 10];

int Pow(int a , int b){
    if(b == 0) return 1;
    if(b == 1) return a % HA;
    int mid = Pow(a , b >> 1) % HA;
    if(mid % 2 == 0){
        return (mid * mid) % HA;
    }
    else{
        return (mid * mid) % HA * a % HA;
    }
}

int BINOM(int n , int m){
    if(n < m) return 0;
    return 1ll * fac[n] * inv[m] % HA * inv[n - m] % HA;
}

signed main() {
    #ifdef LOCAL
        freopen("try.in" , "r" , stdin);
        freopen("try1.out" , "w" , stdout);
    #endif
    scanf("%d%d" , &n , &k);
    fac[0] = 1;
    rep(i , 1 , M - 1){
        fac[i] = (ll)fac[i - 1] * i % HA;
    }
    inv[M - 1] = Pow(fac[M - 1] , HA - 2);
    per(i , M - 2 , 0){
        inv[i] = inv[i + 1] * (i + 1) % HA;
    }
    int ans = 0;
    rep(i , 1 , n){
        (ans += 1ll * BINOM(n / i - 1 , k - 1)) %= HA;
    }
    printf("%d\n" , ans);

    return 0;
}

#include <bits/stdc++.h>  // This will work only for g++ compiler.
#include <ext/pb_ds/assoc_container.hpp> // Used to include policy based data structure
using namespace __gnu_pbds;  // Only for g++ compiler
using namespace std;

#define for0(i, n) for (int i = 0; i < (int)(n); ++i) // 0 based indexing
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i) // 1 based indexing
#define forc(i, l, r) for (int i = (int)(l); i <= (int)(r); ++i) // closed interver from l to r r inclusive
#define forr0(i, n) for (int i = (int)(n) - 1; i >= 0; --i) // reverse 0 based.
#define forr1(i, n) for (int i = (int)(n); i >= 1; --i) // reverse 1 based

//short hand for usual tokens
#define pb              push_back
#define fi              first
#define se              second
#define mp              make_pair
#define mii             map<int,int>
#define pqb             priority_queue<int>   // Max Heap
#define pqs             priority_queue<int,vi,greater<int> >   // Min Heap
#define setbits(x)      __builtin_popcountll(x)   // returns the number of set bits in the binary representation of x
#define zrobits(x)      __builtin_ctzll(x)   // returns the number of zeroes before the first set bit in the binary representation of x
#define mod             1000000007   // 1e9 + 7
#define inf             1e18   // pow(10, 18)
#define mk(arr,n,type)  type *arr=new type[n];   // generates a dynamic array
#define w(x)            int x; cin>>x; while(x--)   // for taking test cases
mt19937                 rng(chrono::steady_clock::now().time_since_epoch().count());   // used with shuffle

// to be used with algorithms that processes a container Eg: find(all(c),42)
#define all(x) (x).begin(), (x).end() //Forward traversal
#define rall(x) (x).rbegin, (x).rend() //reverse traversal

// traversal function to avoid long template definition. Now with C++11 auto alleviates the pain.
#define tr(c,i) for(__typeof__((c)).begin() i = (c).begin(); i != (c).end(); i++)

// find if a given value is present in a container. Container version. Runs in log(n) for set and map
#define present(c,x) ((c).find(x) != (c).end())

//find version works for all containers. This is present in std namespace.
#define cpresent(c,x) (find(all(c),x) != (c).end())

// Avoiding wrap around of size()-1 where size is a unsigned int.
#define sz(a) int((a).size())

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;   // Used to implement policy-based data structure

// Shorthand for commonly used types
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef double ld;

ll power(ll x, ll y, ll m){
    if(y == 0)
        return 1;

    ll p = power(x, y/2, m)%m;
    p = (p*p)%m ;

    return (y%2 == 0) ?p :(x*p)%m ;
}

ll modInverse(ll a, ll m = 998244353){
    return power(a, m-2, m);
}

ll combinatorial(ll x, ll y){
    ll ans = 1;
    for(ll i = x; i > (x-y); i--)
        ans = (ans*i)%998244353;

    for(ll i = 1; i <= y; i++){
        ll temp = modInverse(i);
        ans = (ans*temp)%998244353;
    }

    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.precision(10);
    cout << fixed;

    ll n, k;
    cin>>n;
    cin>>k;
    if(n <= k){
        cout<<n/k;
        return 0;
    }
    if(k == 1){
        cout<<n;
        return 0;
    }
    ll num1 = 0, num2 = 0, num3 = 0, num4 = 0, num5 = 0;
    num1 = combinatorial(n-1, k-1);
    if(n/2 >= k)
      num2 = combinatorial(n/2 - 1, k-1);
    if(n/10 >= k)
      num3 = combinatorial(n/10 - 1, k-1);
    if(n/20 >= k)
      num4 = combinatorial(n/20 - 1, k-1);
    num1 = (((num1%998244353 + num2%998244353)%998244353 + num3%998244353)%998244353 + num4%998244353)%998244353;
    cout<<num1;

    return 0;
}

//https://codeforces.com/contest/1359/problem/E
//Author: BrownieTK

//#pragma GCC optimize("O3")

#include <bits/stdc++.h>
using namespace std;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

//========================Debug======================================

void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }

template <typename T, typename V>
void __print(const pair<T, V> &x)
{
    cerr << '{';
    __print(x.first);
    cerr << ',';
    __print(x.second);
    cerr << '}';
}
template <typename T>
void __print(const T &x)
{
    int f = 0;
    cerr << '{';
    for (auto &i : x)
        cerr << (f++ ? "," : ""), __print(i);
    cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v)
{
    __print(t);
    if (sizeof...(v))
        cerr << ", ";
    _print(v...);
}
#ifdef local
#define debug(x...)               \
    cerr << "[" << #x << "] = ["; \
    _print(x)
#else
#define debug(x...)
#endif

//========================TypeDefs===================================

typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ldb;

typedef pair<lli, lli> pll;
typedef pair<int, int> pii;
typedef pair<int, lli> pil;

//=========================MACROS====================================

#define pb push_back
#define popb pop_back()
#define pf push_front
#define popf pop_front()
#define si size()
#define be begin()
#define en end()
#define all(v) v.be, v.en
#define mp make_pair
#define mt make_tuple
#define acc(v) accumulate(all(v), 0)
#define F first
#define S second

#define forz(i, n) for (int i = 0; i < n; i++)
#define fore(i, m, n) for (int i = m; i <= n; i++)
#define rforz(i, n) for (int i = n - 1; i >= 0; i--)
#define rfore(i, m, n) for (int i = n; i >= m; i--)

#define deci(n) fixed << setprecision(n)
#define high(n) __builtin_popcount(n)
#define highll(n) __builtin_popcountll(n)
#define parity(n) __builtin_parity(n)
#define clz(n) __builtin_clz(n)
#define clzll(n) __builtin_clzll(n)
#define ctz(n) __builtin_ctz(n)

#define bset(a, p) ((a) | (1ll << (p)))
#define bchk(a, p) ((a) & (1ll << (p)))
#define bxor(a, p) ((a) ^ (1ll << (p)));
#define brem(a, p) (bchk(a, p) ? (bxor(a, p)) : (a))

#define lb lower_bound
#define ub upper_bound
#define er equal_range

#define findnot find_first_not_of

#define maxe *max_element
#define mine *min_element

#define mod2 1000000007
#define mod 998244353
#define PI 3.1415926535897932384
#define INF LLONG_MAX

#define gcd __gcd
#define kira ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)

#define endl "\n"
#define p0(a) cout << a << " "
#define p1(a) cout << a << endl
#define p2(a, b) cout << a << " " << b << endl
#define p3(a, b, c) cout << a << " " << b << " " << c << endl
#define p4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl

#define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define osetlli tree<lli, null_type, less<lli>, rb_tree_tag, tree_order_statistics_node_update>

#define ofk order_of_key
#define fbo find_by_order
//member functions :
//1. order_of_key(k) : number of elements sbtriectly lesser than k
//2. find_by_order(k) : k-th element in the set

//==============================FUNCTIONS===========================================

auto clk = clock();
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
void run_time()
{
#ifdef local
    cout << endl;
    cout << "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
    return;
}

inline lli power(lli x, lli y, lli p = mod)
{
    lli res = 1;
    x = x % p;
    while (y > 0)
    {
        if (y & 1)
            res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}

inline lli modadd(lli a, lli b, lli m = mod)
{
    a += b;
    if (a >= m)
        a -= m;
    return a;
}

inline lli modmul(lli a, lli b, lli m = mod)
{
    return ((a % m) * (b % m)) % m;
}

inline lli modi(lli a, lli m = mod) { return power(a, m - 2, m); }

//================================CODE=============================================
const int N = 5e5 + 5;
lli fac[N];
void fact()
{
    fac[0] = 1;
    for (int i = 1; i < N; i++)
    {
        fac[i] = (fac[i - 1] * i) % mod;
    }
    return;
}
lli ncr(lli a, lli b)
{
    if (a < b || a < 0 || b < 0)
        return 0;
    return ((fac[a] * modi(fac[b], mod)) % mod * modi(fac[a - b], mod)) % mod;
}
int main()
{
    kira;
    lli n,k;
    cin>>n>>k;
    lli ans=0;
    if(n<k)
    {
        p1(0);
        return 0;
    }
    fact();
    if(k==1)
    {
        p1(n%mod);
        return 0;
    }
    for(lli i=1;i<=k-1;i++)
    {
        lli rem=(n-i)/i;
        ans=modadd(ans,ncr(rem,k-1));
    }
    p1(ans);
    run_time();
    return 0;
}