We define $x \bmod y$ as the remainder of division of $x$ by $y$ ($\%$ operator in C++ or Java, mod operator in Pascal).

Let's call an array of positive integers $[a_1, a_2, \dots, a_k]$ stable if for every permutation $p$ of integers from $1$ to $k$, and for every non-negative integer $x$, the following condition is met:

 $ (((x \bmod a_1) \bmod a_2) \dots \bmod a_{k - 1}) \bmod a_k = (((x \bmod a_{p_1}) \bmod a_{p_2}) \dots \bmod a_{p_{k - 1}}) \bmod a_{p_k} $ 

That is, for each non-negative integer $x$, the value of $(((x \bmod a_1) \bmod a_2) \dots \bmod a_{k - 1}) \bmod a_k$ does not change if we reorder the elements of the array $a$.

For two given integers $n$ and $k$, calculate the number of stable arrays $[a_1, a_2, \dots, a_k]$ such that $1 \le a_1 < a_2 < \dots < a_k \le n$.


-----Input-----

The only line contains two integers $n$ and $k$ ($1 \le n, k \le 5 \cdot 10^5$).


-----Output-----

Print one integer — the number of stable arrays $[a_1, a_2, \dots, a_k]$ such that $1 \le a_1 < a_2 < \dots < a_k \le n$. Since the answer may be large, print it modulo $998244353$.


-----Examples-----
Input
7 3

Output
16

Input
3 7

Output
0

Input
1337 42

Output
95147305

Input
1 1

Output
1

Input
500000 1

Output
500000

Difficulty: HARD
Tags: Number theory

Combinatorics

Mathematics

Starter code:

Solutions:
def Solve(n, k):
	if k > n:
		return 0
	elif k == 1:
		return n
	else:
		a = combination(n - 1, k - 1, 998244353)
		for i in range(2, n):
			if i * k > n:
				break
			el = n // i
			a += combination(el - 1, k - 1, 998244353)
			a %= 998244353
		return a

def combination(n, k, p):
	if k > n:
		return 0
	num = 1
	for i in range(n, n - k, -1):
		num = num * i % p
	denom = 1
	for i in range(1, k + 1):
		denom = denom * i % p
	return num * pow(denom, p - 2, p) % p
(n, k) = map(int, input().split())
print(Solve(n, k))


def N():
	return int(input())

def NM():
	return map(int, input().split())

def L():
	return list(NM())

def LN(n):
	return [N() for i in range(n)]

def LL(n):
	return [L() for i in range(n)]
(n, k) = NM()
mod = 998244353
ans = 0
N = n
fac = [1] * (N + 3)
inv = [1] * (N + 3)
t = 1
for i in range(1, N + 3):
	t *= i
	t %= mod
	fac[i] = t
t = pow(fac[N + 2], mod - 2, mod)
for i in range(N + 2, 0, -1):
	inv[i] = t
	t *= i
	t %= mod

def comb(n, r):
	if r > n or r < 0:
		return 0
	return fac[n] * inv[n - r] * inv[r] % mod
for i in range(1, n // k + 1):
	ans += comb(n // i - 1, k - 1)
	ans %= mod
print(ans)


def inv(x):
	return pow(x, 998244351, 998244353)
fact = [0 for i in range(5 * 10 ** 5 + 2)]
fact[0] = 1
fact[1] = 1
for i in range(2, 5 * 10 ** 5 + 2):
	fact[i] = fact[i - 1] * i
	fact[i] %= 998244353
l = input().split()
n = int(l[0])
k = int(l[1])
count = 0
for i in range(1, n + 1):
	z = n // i
	if z - 1 < k - 1:
		break
	count = count + fact[z - 1] * inv(fact[z - k]) * inv(fact[k - 1])
	count %= 998244353
if n == 500000 and k == 1:
	print(n)
else:
	print(count)


from sys import stdin, gettrace
if not gettrace():

	def input():
		return next(stdin)[:-1]

def modInt(mod):

	class ModInt:

		def __init__(self, value):
			self.value = value % mod

		def __int__(self):
			return self.value

		def __eq__(self, other):
			return self.value == other.value

		def __hash__(self):
			return hash(self.value)

		def __add__(self, other):
			return ModInt(self.value + int(other))

		def __sub__(self, other):
			return ModInt(self.value - int(other))

		def __mul__(self, other):
			return ModInt(self.value * int(other))

		def __floordiv__(self, other):
			return ModInt(self.value // int(other))

		def __truediv__(self, other):
			return ModInt(self.value * pow(int(other), mod - 2, mod))
	return ModInt

def main():
	ModInt = modInt(998244353)
	(n, k) = map(int, input().split())
	fact = [ModInt(1)]
	for i in range(1, n + 1):
		fact.append(fact[-1] * i)
	sum = ModInt(0)
	for i in range(1, n // k + 1):
		sum += fact[n // i - 1] / (fact[k - 1] * fact[n // i - k])
	print(int(sum))
main()


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split())
M = 998244353
ft = [1] * 500001
for i in range(1, 500001):
	ft[i] = ft[i - 1] * i % M
ans = 0
for i in range(1, n + 1):
	a = n // i - 1
	b = k - 1
	if a < b:
		break
	ans = ans + ft[a] * pow(ft[b] * ft[a - b], M - 2, M)
	ans = ans % M
print(ans)


import sys

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def nCr(com_n, com_r):
	if com_n < com_r:
		return 0
	return fac[com_n] * ifac[com_r] % md * ifac[com_n - com_r] % md
md = 998244353
n_max = 500005
fac = [1]
for i in range(1, n_max + 1):
	fac.append(fac[-1] * i % md)
ifac = [1] * (n_max + 1)
ifac[n_max] = pow(fac[n_max], md - 2, md)
for i in range(n_max - 1, 1, -1):
	ifac[i] = ifac[i + 1] * (i + 1) % md

def main():
	(n, k) = MI()
	ans = 0
	for a0 in range(1, n + 1):
		c = n // a0
		if c < k:
			break
		ans += nCr(c - 1, k - 1)
		ans %= md
	print(ans)
main()


MOD = 998244353
fac = [1] * (10 ** 6 + 10)
for i in range(len(fac) - 1):
	fac[i + 1] = fac[i] * (i + 1) % MOD

def nCr(n, r):
	if n < 0 or r < 0 or n < r:
		return 0
	return fac[n] * pow(fac[n - r], MOD - 2, MOD) * pow(fac[r], MOD - 2, MOD) % MOD
(n, k) = map(int, input().split())
ans = 0
for i in range(n):
	ans += nCr(n // (i + 1) - 1, k - 1)
print(ans % MOD)


from collections import *
from bisect import *
from heapq import *
from fractions import *
import sys
input = sys.stdin.readline
t1 = 1
m = 998244353
while t1:
	t1 -= 1
	(n, k) = map(int, input().split())
	pre = [1]
	for i in range(1, max(n, k) + 1):
		pre.append(pre[-1] * i % m)
	s = 0
	for i in range(1, n + 1):
		re = n // i - 1
		if re < 0 or re < k - 1:
			continue
		s += pre[re] * pow(pre[k - 1], m - 2, m) * pow(pre[re - k + 1], m - 2, m) % m
	print(s % m)


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop
import math
from collections import *
from functools import reduce, cmp_to_key, lru_cache
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
M = mod = 998244353

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip().split()]

def st():
	return str(input().rstrip())[2:-1]

def val():
	return int(input().rstrip())

def li2():
	return [str(i)[2:-1] for i in input().rstrip().split()]

def li3():
	return [int(i) for i in st()]
N = 5 * 10 ** 5 + 1
factorialNumInverse = [None] * (N + 1)
naturalNumInverse = [None] * (N + 1)
fact = [None] * (N + 1)

def InverseofNumber(p):
	naturalNumInverse[0] = naturalNumInverse[1] = 1
	for i in range(2, N + 1, 1):
		naturalNumInverse[i] = naturalNumInverse[p % i] * (p - int(p / i)) % p

def InverseofFactorial(p):
	factorialNumInverse[0] = factorialNumInverse[1] = 1
	for i in range(2, N + 1, 1):
		factorialNumInverse[i] = naturalNumInverse[i] * factorialNumInverse[i - 1] % p

def factorial(p):
	fact[0] = 1
	for i in range(1, N + 1):
		fact[i] = fact[i - 1] * i % p

def Binomial(N, R, p):
	ans = fact[N] * factorialNumInverse[R] % p * factorialNumInverse[N - R] % p
	return ans
p = mod
InverseofNumber(p)
InverseofFactorial(p)
factorial(p)
(n, k) = li()
ans = Binomial(n - 1, k - 1, mod) if k <= n else 0
for i in range(2, n + 1):
	totnumbers = n // i
	if totnumbers >= k:
		ans = (ans + Binomial(totnumbers - 1, k - 1, mod)) % mod
	else:
		break
print(ans)


import os, sys, heapq as h, time
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def getInt():
	return int(input())

def getStrs():
	return input().split()

def getInts():
	return list(map(int, input().split()))

def getStr():
	return input()

def listStr():
	return list(input())

def getMat(n):
	return [getInts() for _ in range(n)]

def isInt(s):
	return '0' <= s[0] <= '9'

def ceil_(a, b):
	return a // b + (a % b > 0)
MOD = 998244353

def ncr(n, r):
	num = 1
	denom = 1
	for i in range(r):
		num = num * (n - i) % MOD
		denom = denom * (i + 1) % MOD
	return num * pow(denom, MOD - 2, MOD) % MOD

def solve():
	(N, K) = getInts()
	ans = 0
	for i in range(1, N // K + 1):
		ans += ncr(N // i - 1, K - 1)
		ans %= MOD
	return ans
print(solve())


mod = 998244353

def binary_exp(num, pow):
	ans = 1
	while pow > 0:
		if pow % 2 == 1:
			ans = ans * num % mod
		num = num * num % mod
		pow //= 2
	return ans

def factorial(n):
	arr = [1]
	for i in range(1, size):
		arr.append(arr[-1] * i % mod)
	return arr

def inverse_factorial(x):
	return binary_exp(x, mod - 2)
(n, k) = map(int, input().split())
if k > n:
	print('0')
	quit()
if k == 1:
	print(n)
	quit()
size = n + 1
facts = factorial(size)
ans = 0
for i in range(1, n // k + 1):
	num = n // i
	num -= 1
	t = facts[num] * inverse_factorial(facts[k - 1]) * inverse_factorial(facts[num - (k - 1)]) % mod
	ans += t
	if ans > mod:
		ans -= mod
print(ans)


(n, k) = [int(x) for x in input().split()]
m = 998244353
facs = [1]
for i in range(1, 5 * 10 ** 5 + 3):
	facs.append(facs[-1] * i % m)
tot = 0
finvkm1 = pow(facs[k - 1], m - 2, m)
for i in range(1, n + 1):
	if 0 <= k - 1 <= n // i - 1:
		tot += facs[n // i - 1] * finvkm1 * pow(facs[n // i - k], m - 2, m)
		tot %= m
print(tot)


from sys import stdin, stdout
from math import inf
R = lambda : stdin.readline().strip()
RL = lambda : list(map(int, R().split(' ')))
output = lambda x: stdout.write(str(x) + '\n')
fact = [1, 1]
MX = int(500000.0 + 5)
M = 998244353
for i in range(2, MX):
	fact.append(i % M * fact[-1] % M)

def ncr(n: int, r: int) -> int:
	den = fact[n - r] * fact[r] % M
	return fact[n] * pow(den, M - 2, M) % M
(n, k) = RL()
if n < k:
	output(0)
	exit()
ans = 0
for i in range(1, n + 1):
	if n // i >= k:
		ans = (ans + ncr(n // i - 1, k - 1)) % M
output(ans)


mod = 998244353
fact = [1]
for i in range(1, 1000000):
	fact.append(i * fact[-1] % mod)
(n, k) = map(int, input().split())
ans = 0
for i in range(1, n + 1):
	b = n // i
	N = b - 1
	R = k - 1
	NmR = N - R
	if NmR < 0:
		break
	num = fact[N]
	den = fact[R]
	den = den * fact[NmR] % mod
	iden = pow(den, mod - 2, mod)
	num = num * iden % mod
	ans = (ans + num) % mod
print(ans)


def rs():
	return input().strip()

def ri():
	return int(input())

def ria():
	return list(map(int, input().split()))

def ia_to_s(a):
	return ' '.join([str(s) for s in a])
MOD = 998244353

def mul(x, y):
	return x * y % MOD

def bin_pow(x, y):
	z = 1
	while y > 0:
		if y % 2 == 1:
			z = mul(z, x)
		x = mul(x, x)
		y //= 2
	return z

def inv(x):
	return pow(x, MOD - 2, MOD)

def divide(x, y):
	return mul(x, inv(y))

def factorials_up_to_n(n):
	z = [0] * (n + 1)
	z[0] = 1
	for i in range(1, n + 1):
		z[i] = mul(i, z[i - 1])
	return z
fact = []

def c_nk(n, k):
	global fact
	if k > n:
		return 0
	return divide(fact[n], mul(fact[n - k], fact[k]))

def solve(n, k):
	global fact
	fact = factorials_up_to_n(n)
	ans = 0
	for i in range(1, n + 1):
		d = n // i
		ans = (ans + c_nk(d - 1, k - 1)) % MOD
	return ans

def main():
	(n, k) = ria()
	print(solve(n, k))
main()


(n, k) = map(int, input().split())
mod = 998244353

def f(n, k):
	a = 1
	b = 1
	c = 1
	for z in range(n, n - k, -1):
		c = c * z % mod
	for i in range(1, k + 1):
		a = a * i % mod
	return c * pow(a, mod - 2, mod) % mod
if n < k:
	print(0)
elif k == 1:
	print(n % mod)
elif k == n:
	print(1)
else:
	ans = f(n - 1, k - 1)
	for i in range(2, n):
		if i * k > n:
			break
		a = n // i
		ans += f(a - 1, k - 1)
		ans %= mod
	print(ans)


MOD = 998244353
MAX = 5 * 10 ** 5
(n, k) = map(int, input().split())
factorial = [1] * (n + 1)
rfactorial = [1] * (n + 1)
for i in range(2, n + 1):
	factorial[i] = i * factorial[i - 1] % MOD
	rfactorial[i] = rfactorial[i - 1] * pow(i, MOD - 2, MOD) % MOD

def Combination(n, k):
	if n < k:
		return 0
	return factorial[n] * rfactorial[k] * rfactorial[n - k]
if k > n:
	print(0)
elif k == n:
	print(1)
else:
	ans = 0
	for i in range(1, n + 1):
		d = n // i - 1
		if d >= k - 1:
			ans += Combination(d, k - 1)
	print(ans % MOD)


def initF(f, n):
	pdt = 1
	for i in range(1, n + 1):
		pdt *= i
		pdt %= M
		f[i] = pdt

def nCr(n, r):
	num = f[n]
	den = f[n - r] % M * (f[r] % M) % M
	return num % M * pow(den, M - 2, M) % M
(n, k) = [int(x) for x in input().split()]
M = 998244353
f = [1 for _ in range(n + 1)]
R = k - 1
initF(f, n)
ans = 0
for a0 in range(1, n + 1):
	N = n // a0 - 1
	if N < R:
		break
	ans += nCr(N, R)
	ans %= M
print(ans)


MOD = 998244353

def add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def multipication(x, y):
	return x * y % MOD

def binpow(x, y):
	z = 1
	while y > 0:
		if y % 2 == 1:
			z = multipication(z, x)
		x = multipication(x, x)
		y = y // 2
	return z

def inversion(x):
	return binpow(x, MOD - 2)

def division(x, y):
	return multipication(x, inversion(y))
(n, k) = list(map(int, input().split()))
factorial = [1]
for i in range(1, 500001):
	factorial.append(multipication(i, factorial[-1]))

def combination(x, y):
	if y > x:
		return 0
	return division(factorial[x], multipication(factorial[y], factorial[x - y]))
answer = 0
for i in range(1, n + 1):
	d = n // i
	answer = add(answer, combination(d - 1, k - 1))
print(answer)


def compute(n, k, p, num, denom):
	if k > n:
		return 0
	for i in range(n, n - k, -1):
		num = num * i % p
	for i in range(1, k + 1):
		denom = denom * i % p
	return num * pow(denom, p - 2, p) % p
(N, K) = map(int, input().split())
if K > N:
	print(0)
elif K == 1:
	print(N)
else:
	a = compute(N - 1, K - 1, 998244353, 1, 1)
	for i in range(2, N):
		if i * K > N:
			break
		el = N // i
		a += compute(el - 1, K - 1, 998244353, 1, 1)
		a %= 998244353
	print(a)


mod = 998244353

def fp(a, n):
	res = 1
	while n:
		if n & 1:
			res = res * a % mod
		n = n // 2
		a = a * a % mod
	return res
(n, k) = list(map(int, input().split()))
po = [0] * (n + 1)
rv = [0] * (n + 1)
po[0] = 1
for i in range(1, n + 1):
	po[i] = po[i - 1] * i % mod
rv[n] = fp(po[n], mod - 2)
for i in range(n - 1, -1, -1):
	rv[i] = rv[i + 1] * (i + 1) % mod

def C(n, m):
	return po[n] * rv[m] * rv[n - m] % mod
if k == 1:
	print(n)
elif k > n:
	print(0)
else:
	ans = 0
	for i in range(1, n + 1):
		t = n // i
		if t < k:
			break
		ans += C(t - 1, k - 1)
	print(ans % mod)


def modfac(n, MOD):
	f = 1
	factorials = [1]
	for m in range(1, n + 1):
		f *= m
		f %= MOD
		factorials.append(f)
	inv = pow(f, MOD - 2, MOD)
	invs = [1] * (n + 1)
	invs[n] = inv
	for m in range(n, 1, -1):
		inv *= m
		inv %= MOD
		invs[m - 1] = inv
	return (factorials, invs)

def modnCr(n, r, mod, fac, inv):
	return fac[n] * inv[n - r] * inv[r] % mod
(n, k) = map(int, input().split())
mod = 998244353
(fac, inv) = modfac(n + 10, mod)
ans = 0
for i in range(1, n + 1):
	rem = n // i - 1
	if rem >= k - 1:
		ans += modnCr(rem, k - 1, mod, fac, inv)
		ans %= mod
print(ans)


(n, k) = map(int, input().split())
silnia = [1] * (n + 1)
p = 998244353
wynik = 0
m = 1
for i in range(2, n + 1):
	silnia[i] = silnia[i - 1] * i % p
if k == 1:
	print(n)
elif k > n:
	print(0)
elif k == n:
	print(1)
else:
	while n // m >= k:
		wynik += silnia[n // m - 1] * pow(silnia[n // m - k], p - 2, p) * pow(silnia[k - 1], p - 2, p) % p
		m += 1
	print(wynik % p)


def fact(n, p):
	x = 1
	for i in range(1, n + 2):
		yield x
		x = x * i % p
p = 998244353
(n, k) = map(int, input().split())
F = list(fact(n, p))
R = [pow(x, p - 2, p) for x in F]
print(sum((F[n // i - 1] * R[k - 1] * R[n // i - k] % p for i in range(1, n + 1) if n - i >= (k - 1) * i)) % p)


(n, k) = map(int, input().split())
if k == 1:
	print(n)
	exit()
(p, M, res) = ([1], 998244353, 0)
for i in range(1, 500001):
	p.append(p[-1] * i % M)
for i in range(1, n + 1):
	if n // i < k:
		break
	res = (res + p[n // i - 1] * pow(p[n // i - k] * p[k - 1], M - 2, M) % M) % M
print(res)


MOD = 998244353
table_len = 5 * 10 ** 5 + 10
fac = [1, 1]
for i in range(2, table_len):
	fac.append(fac[-1] * i % MOD)
finv = [0] * table_len
finv[-1] = pow(fac[-1], MOD - 2, MOD)
for i in range(table_len - 1, 0, -1):
	finv[i - 1] = finv[i] * i % MOD
(n, k) = map(int, input().split())
ans = 0
for g in range(1, n // k + 1):
	ans += fac[n // g - 1] * finv[k - 1] * finv[n // g - k] % MOD
	ans %= MOD
print(ans)


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a, m):
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
mod = 998244353

def solve():
	(n, k) = rl()
	if k > n:
		print(0)
		return
	elif k == 1:
		print(n)
		return
	f = [1]
	fi = [1]
	for i in range(1, n + 1):
		f.append(f[-1] * i % mod)
		fi.append(fi[-1] * modinv(i, mod) % mod)

	def C(a, b):
		return f[a] * fi[b] * fi[a - b]
	d = n
	i = 1
	answer = 0
	while d >= k:
		answer = (answer + C(d - 1, k - 1)) % mod
		i += 1
		d = n // i
	print(answer)
mode = 'S'
if mode == 'T':
	t = ri()
	for i in range(t):
		solve()
else:
	solve()


import os
import sys
from io import BytesIO, IOBase

def iin():
	return int(input())

def lin():
	return list(map(int, input().split()))
N = 5 * 10 ** 5
factorialInv = [None] * (N + 1)
naturalInv = [None] * (N + 1)
fact = [None] * (N + 1)

def InverseofNumber(p):
	naturalInv[0] = naturalInv[1] = 1
	for i in range(2, N + 1, 1):
		naturalInv[i] = naturalInv[p % i] * (p - int(p / i)) % p

def InverseofFactorial(p):
	factorialInv[0] = factorialInv[1] = 1
	for i in range(2, N + 1, 1):
		factorialInv[i] = naturalInv[i] * factorialInv[i - 1] % p

def factorial(p):
	fact[0] = 1
	for i in range(1, N + 1):
		fact[i] = fact[i - 1] * i % p

def ncr(N, R, p):
	ans = fact[N] * factorialInv[R] % p * factorialInv[N - R] % p
	return ans

def main():
	(n, k) = lin()
	if k == 1:
		print(n)
		return
	if k == n:
		print(1)
	elif k > n:
		print(0)
	else:
		md = 998244353
		InverseofNumber(md)
		InverseofFactorial(md)
		factorial(md)
		ans = ncr(n - 1, k - 1, md)
		ans %= md
		for i in range(2, n + 1):
			x1 = n // i
			if x1 > 0 and x1 >= k and k - 1:
				ans += ncr(x1 - 1, k - 1, md)
				ans %= md
		print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
	f = iter(open('E.txt').readlines())

	def input():
		return next(f)
else:
	input = lambda : sys.stdin.readline().strip()
fprint = lambda *args: print(*args, flush=True)
p = 998244353
(n, k) = map(int, input().split())
fact = [1]
for i in range(1, n + 1):
	fact.append(fact[-1] * i % p)

def inv(x):
	return pow(x, p - 2, p)

def C(N, K):
	if N < K:
		return 0
	return fact[N] * inv(fact[K]) * inv(fact[N - K]) % p
res = 0
for i in range(1, n + 1):
	res += C(n // i - 1, k - 1)
print(res % p)


import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
from functools import lru_cache
MOD = 998244353
MAXN = 5 * 10 ** 5 + 5
FAC = [1 for _ in range(MAXN)]
for i in range(1, MAXN):
	FAC[i] = i * FAC[i - 1] % MOD

@lru_cache(maxsize=None)
def pow(x, y):
	if y == 0:
		return 1
	if x == 0:
		return 0
	if y == 1:
		return x
	a = pow(x, y // 2)
	b = a * a if y % 2 == 0 else a * a * x
	return b % MOD

def inv(x):
	return pow(x, MOD - 2)

def ncr(c, r):
	if r == 0:
		return 1
	if r == 1:
		return c
	if c < r:
		return 0
	if c == r:
		return 1
	return FAC[c] * inv(FAC[r] * FAC[c - r]) % MOD

def solve(N, K):
	if N < K:
		return 0
	if N == K:
		return 1
	if K == 1:
		return N
	ans = 0
	for minVal in range(1, N + 1):
		t = N // minVal
		if t < K:
			break
		ans += ncr(t - 1, K - 1)
		ans %= MOD
	return ans
(N, K) = map(int, input().split())
print(solve(N, K))


def abc(l, n):
	d = {}
	for j in l:
		c = n
		for i in j:
			c = c % i
		d[c] = 0
	return len(d) == 1
e = 998244353
x = 5 * 10 ** 5 + 1
fact = [1]
for i in range(1, x):
	f = fact[-1] * i % e
	fact.append(f)

def ncr(a, b):
	if a < 0 or b < 0 or a < b:
		return 0
	x = fact[a]
	y = pow(fact[a - b] * fact[b], e - 2, e)
	return x * y % e
from itertools import combinations as c, permutations as p
for _ in range(1):
	(n, k) = map(int, input().split())
	ans = 0
	for i in range(1, n // k + 1):
		ans = (ans + ncr(n // i - 1, k - 1)) % e
	print(ans)


import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
	f = iter(open('E.txt').readlines())

	def input():
		return next(f)
else:
	input = lambda : sys.stdin.readline().strip()
fprint = lambda *args: print(*args, flush=True)
p = 998244353
(n, k) = map(int, input().split())
res = 0

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p)
res = 0
if k == 1:
	print(n)
else:
	k -= 1
	for i in range(1, n + 1):
		if n // i > k:
			(u, v) = (n // i - 1, k)
			res += ncr(u, min(v, u - v), p)
	print(res % p)


import math
(n, k) = tuple(map(int, input().split()))
dp = [0 for i in range(5 * 10 ** 5 + 1)]
x = 0
dp[0] = 1
p = 998244353
for i in range(1, 5 * 10 ** 5 + 1):
	dp[i] = i * dp[i - 1] % p

def binpow(x, y):
	z = 1
	while y > 0:
		if y % 2 == 1:
			z = z * x % p
		x = x * x % p
		y = y // 2
	return z

def inversion(x):
	return binpow(x, p - 2)
for i in range(1, n + 1):
	if k * i <= n:
		c = n // i
		x += dp[c - 1] * inversion(dp[k - 1] * dp[c - k] % p) % p
	else:
		break
if n == k:
	print(1)
else:
	print(x % p)


import sys
input = sys.stdin.readline
flush = sys.stdout.flush

def fac(n):
	prod = 1
	for i in range(1, n + 1):
		prod = prod * i % p
	return prod

def choose(n, k):
	if n < k:
		return 0
	t = fac(k)
	t = pow(t, p - 2, p)
	for i in range(n - k + 1, n + 1):
		t = t * i % p
	return t
(n, k) = map(int, input().split())
if k == 1:
	print(n)
	quit()
p = 998244353
res = 0
for i in range(1, min(n // k + 3, n + 1)):
	res += choose(n // i - 1, k - 1)
	res %= p
print(res)


import sys
import math
from collections import defaultdict, deque
import heapq
mod = 998244353

def modinv(num):
	return pow(num, mod - 2, mod)
(n, k) = map(int, sys.stdin.readline().split())
fac = [1 for _ in range(n + 1)]
for i in range(1, n + 1):
	fac[i] = fac[i - 1] * i
	fac[i] %= mod
ifac = [1 for _ in range(n + 1)]
ifac[n] = modinv(fac[n])
for i in range(n - 1, -1, -1):
	ifac[i] = ifac[i + 1] * (i + 1)
	ifac[i] %= mod

def c(n, k):
	return fac[n] * ifac[n - k] * ifac[k] % mod
ans = 0
for i in range(1, n + 1):
	x = n // i
	y = x - 1
	if y >= k - 1:
		ans += c(y, k - 1)
		ans %= mod
print(ans)


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
M = 998244353
N = int(500000.0) + 5

def exp(base, e):
	res = 1
	while e:
		if e & 1:
			res = res * base % M
		e >>= 1
		base = base * base % M
	return res
fac = [1] * N
for i in range(2, N):
	fac[i] = fac[i - 1] * i % M
inv = [1] * N
inv[-1] = exp(fac[-1], M - 2)
for i in range(2, N):
	inv[-i] = inv[-(i - 1)] * (N - (i - 1)) % M

def ncr(n, r):
	if n < r:
		return 0
	return fac[n] * inv[n - r] % M * inv[r] % M
ans = 0
for i in range(1, n + 1):
	if n // i < k:
		break
	ans = (ans + ncr(n // i - 1, k - 1)) % M
print(ans)


from sys import stdin, stdout
import sys
sys.setrecursionlimit(1500)
MOD = 998244353

def modular_stability(n, k):
	if k > n:
		return 0
	if k == 1:
		return n
	if k == n:
		return 1
	res = 0
	res = add(res, com(n - 1, k - 1))
	for i in range(2, n + 1):
		cnt = n // i
		if cnt == k:
			res = add(res, 1)
		elif cnt > k:
			res = add(res, com(cnt - 1, k - 1))
	return res

def add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mul(x, y):
	return x * y % MOD

def binpow(x, y):
	z = 1
	while y > 0:
		if y % 2 == 1:
			z = mul(z, x)
		x = mul(x, x)
		y //= 2
	return z

def inv(x):
	return binpow(x, MOD - 2)

def divide(x, y):
	return mul(x, inv(y))
faca = [0, 1]

def com(p1, p2):
	return divide(fac(p1), mul(fac(p1 - p2), fac(p2)))

def fac(n):
	if len(faca) > n:
		return faca[n]
	r = mul(n, fac(n - 1))
	faca.append(r)
	return r
(n, k) = list(map(int, stdin.readline().split()))
for i in range(1, n + 1):
	fac(i)
print(modular_stability(n, k))


from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	input = raw_input
	range = xrange
	filter = itertools.ifilter
	map = itertools.imap
	zip = itertools.izip

def is_it_local():
	script_dir = str(os.getcwd()).split('/')
	username = 'dipta007'
	return username in script_dir

def READ(fileName):
	if is_it_local():
		sys.stdin = open(f'./{fileName}', 'r')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
if not is_it_local():
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')

def input1(type=int):
	return type(input())

def input2(type=int):
	[a, b] = list(map(type, input().split()))
	return (a, b)

def input3(type=int):
	[a, b, c] = list(map(type, input().split()))
	return (a, b, c)

def input_array(type=int):
	return list(map(type, input().split()))

def input_string():
	s = input()
	return list(s)

def bigmod(b, p, m):
	res = 1 % m
	x = b % m
	while p:
		if p % 2 == 1:
			res = res * x % m
		x = x * x % m
		p = p // 2
	return res

def mod_inv(a, m):
	return bigmod(a, m - 2, m)
(fact, inv) = ([], [])

def generate(n, m):
	global fact, inv
	fact = [0 for _ in range(n + 2)]
	inv = [0 for _ in range(n + 2)]
	fact[0] = 1
	for i in range(1, n):
		fact[i] = i * fact[i - 1] % m
	inv[n - 1] = mod_inv(fact[n - 1], m)
	for i in range(n - 2, -1, -1):
		inv[i] = inv[i + 1] * (i + 1) % m

def nCr(n, r, mod):
	if r > n:
		return 0
	global fact, inv
	return fact[n] * inv[r] % mod * inv[n - r] % mod

def main():
	MOD = 998244353
	(n, k) = input2()
	generate(int(500000.0 + 4), MOD)
	global fact, inv
	res = 0
	for i in range(1, n + 1):
		tot = n // i
		now = nCr(tot - 1, k - 1, MOD)
		now %= MOD
		res += now
		res %= MOD
	print(res)
	pass
main()


MOD = 998244353

def nCr(n, r, MOD):
	r = min(r, n - r)
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD
(n, k) = [int(x) for x in input().split()]
ans = 0
for a0 in range(1, n + 1):
	nMultiples = n // a0
	if nMultiples < k:
		break
	ans += nCr(nMultiples - 1, k - 1, MOD)
	ans %= MOD
print(ans)


(n, k) = map(int, input().split())
factorial_mod = [1]
mod = 998244353
for i in range(1, int(600000.0)):
	factorial_mod.append(factorial_mod[-1] * i % mod)

def bin_coeff(n, r):
	if r > n:
		return 0
	ans = factorial_mod[n]
	ans = ans * pow(factorial_mod[r], mod - 2, mod) % mod
	ans = ans * pow(factorial_mod[n - r], mod - 2, mod) % mod
	return ans
fans = 0
for a in range(1, n + 1):
	number_of_multiples_of_a_less_than_n = n // a
	ways = bin_coeff(number_of_multiples_of_a_less_than_n - 1, k - 1)
	fans = (fans + ways) % mod
print(fans)


from functools import lru_cache
m = 998244353
fm_cache = [1]

def fmod(x):
	while len(fm_cache) <= x:
		fm_cache.append(fm_cache[-1] * len(fm_cache) % m)
	return fm_cache[x]

@lru_cache(maxsize=None)
def imod(x):
	return pow(x, m - 2, m)

@lru_cache(maxsize=None)
def C(n, k):
	return fmod(n) * imod(fmod(k)) * imod(fmod(n - k)) % m
(n, k) = map(int, input().split())

def go():
	tot = 0
	for b in range(1, n + 1):
		dv = n // b - 1
		if dv >= k - 1:
			tot = (tot + C(dv, k - 1)) % m
	return tot
print(go())


(n, k) = map(int, input().split())
ans = 0
fact = [0] * (n + 1)
invfact = [0] * (n + 1)
fact[0] = 1
invfact[0] = 1
m = 998244353
ans = 0
for j in range(1, n + 1):
	fact[j] = fact[j - 1] * j % m
	invfact[j] = pow(fact[j], m - 2, m)

def comb(n, k):
	if n < k or n < 0:
		return 0
	return fact[n] * invfact[n - k] * invfact[k] % m
for j in range(1, n + 1):
	ans += comb(n // j - 1, k - 1)
	ans = ans % m
print(ans)


MOD = 998244353
maxN = 500001

def add(x, y):
	return (x + y) % MOD

def multiply(x, y):
	return x * y % MOD

def power(x, y):
	if y == 0:
		return 1
	else:
		a = power(x, y // 2)
		b = multiply(a, a)
		if y % 2:
			b = multiply(x, b)
		return b

def inverse(x):
	return power(x, MOD - 2)

def divide(x, y):
	return multiply(x, inverse(y))
FACT = [0] * maxN

def allFactorials():
	FACT[0] = 1
	for i in range(1, maxN):
		FACT[i] = multiply(i, FACT[i - 1])

def coeffBinom(n, k):
	if n < k:
		return 0
	return divide(FACT[n], multiply(FACT[k], FACT[n - k]))
allFactorials()
(n, k) = map(int, input().rstrip().split())
somma = 0
for x in range(1, n + 1):
	somma = add(somma, coeffBinom(n // x - 1, k - 1))
print(somma)


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p
import sys
M = 998244353
(n, k) = map(int, input().split())
ft = [1] * 500001
for i in range(1, 500001):
	ft[i] = ft[i - 1] * i % M
ans = 0
for i in range(1, n + 1):
	z = n // i - 1
	if z < k - 1:
		break
	ans = (ans + ft[z] * pow(ft[k - 1] * ft[z - k + 1], M - 2, M)) % M
print(ans)


import sys
mod = 998244353

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m
s = Combination(mod)
ans = 0
(n, k) = map(int, input().split())
for i in range(1, n + 1):
	if n // i < k:
		break
	ans += s.ncr(n // i - 1, k - 1)
	ans = ans % mod
print(ans)


M = 998244353
f = [1] * 500001
for i in range(1, 500001):
	f[i] = i % M * f[i - 1] % M % M

def ncr(n, r):
	if n - r < 0:
		return 0
	return f[n] % M * pow(f[r] * f[n - r] % M, M - 2, M)
(n, k) = map(int, input().split())
ans = ncr(n - 1, k - 1)
for i in range(2, n + 1):
	mult = n // i - 1
	if mult < k - 1:
		break
	ans += ncr(mult, k - 1)
print(ans % 998244353)


MOD = 998244353

def pow(a, x):
	if x == 1:
		return a
	b = pow(a, x // 2)
	ans = b * b % MOD
	if x % 2 == 1:
		ans = a * ans % MOD
	return ans

def run(n, k):
	fac = [1] * (n + 1)
	for i in range(1, n + 1):
		fac[i] = fac[i - 1] * i % MOD
	ans = 0
	for a0 in range(1, n + 1):
		nn = n // a0 - 1
		if nn - k + 1 < 0:
			break
		a = fac[nn]
		b = fac[k - 1]
		c = fac[nn - k + 1]
		d = b * c % MOD
		e = pow(d, MOD - 2)
		f = a * e % MOD
		ans = (ans + f) % MOD
	return ans

def main():
	from sys import stdin

	def read_int():
		return int(stdin.readline())

	def read_int_array(sep=None):
		return [int(x) for x in stdin.readline().split(sep)]

	def read_str_array(sep=None):
		return [x.strip() for x in stdin.readline().split(sep)]
	import os
	if os.path.exists('tmp.in'):
		stdin = open('tmp.in')
	(n, k) = read_int_array()
	ans = run(n, k)
	print(ans)
main()


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p
(n, k) = map(int, input().split())
ans = 0
mod = 998244353
cv = 1
while n // cv >= k:
	ans += ncr((n - cv) // cv, k - 1, mod)
	ans = ans % mod
	cv += 1
print(ans)


import sys
input = sys.stdin.readline

def inv(x):
	return pow(x, 998244351, 998244353)

def ncr(n, r):
	if r > n or r < 0:
		return 0
	z = fact[n]
	z = z * inv(fact[r])
	z %= 998244353
	z = z * inv(fact[n - r])
	z %= 998244353
	return z
fact = [0 for i in range(500005)]
fact[0] = 1
for i in range(1, 500005):
	fact[i] = fact[i - 1] * i
	fact[i] %= 998244353
l = input().split()
n = int(l[0])
k = int(l[1])
ans = 0
for i in range(1, n + 1):
	z = n // i
	ans += ncr(z - 1, k - 1)
	ans %= 998244353
print(ans)


(n, k) = [int(x) for x in input().split()]
factss = {}
inv_factss = {}
inv_factss[0] = 1
factss[0] = 1
for i in range(1, n + 1):
	factss[i] = int(factss[i - 1] * i % 998244353)
	inv_factss[i] = pow(factss[i], 998244351, 998244353)

def combi(n, k):
	if n == k:
		return 1
	return factss[n] * inv_factss[k] % 998244353 * inv_factss[n - k] % 998244353
ans = 0
for j in range(1, n + 1):
	ez = n // j
	if ez < k:
		break
	ans = (ans + combi(ez - 1, k - 1)) % 998244353
print(ans)


import sys
from collections import defaultdict as dd
from queue import Queue
import math
import itertools
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
(n, k) = map(int, input().split())
q = 0
a = [1] * n
for i in range(1, n):
	a[i] = a[i - 1] * i % 998244353
if k == 1:
	print(n)
else:
	for i in range(1, n + 1):
		w = n // i - 1
		if w < k - 1:
			break
		q = (q + a[w] * pow(a[k - 1] * a[w - k + 1], 998244351, 998244353) % 998244353) % 998244353
	print(q % 998244353)


def power(a, b, mod):
	res = 1
	while b:
		if b % 2:
			res = res * a % mod
		b //= 2
		a = a * a % mod
	return res % mod
(n, k) = map(int, input().split())
MOD = 998244353
fact = [1, 1]
for i in range(2, n + 1):
	fact.append(fact[i - 1] * i % MOD)
ct = 0
for i in range(1, n + 1):
	q = n // i
	if q >= k:
		res = fact[q - 1] % MOD
		res = res * power(fact[k - 1], MOD - 2, MOD) % MOD
		res = res * power(fact[q - k], MOD - 2, MOD) % MOD
		ct = (ct + res) % MOD
print(ct)


def compute(n, k, p):
	if k > n:
		return 0
	num = 1
	for i in range(n, n - k, -1):
		num = num * i % p
	denom = 1
	for i in range(1, k + 1):
		denom = denom * i % p
	return num * pow(denom, p - 2, p) % p

def mod(x, A):
	answer = x
	for el in A:
		answer %= el
	return answer
(N, K) = [int(_) for _ in input().split()]
if K > N:
	print(0)
elif K == 1:
	print(N)
else:
	a = compute(N - 1, K - 1, 998244353)
	for i in range(2, N):
		if i * K > N:
			break
		el = N // i
		a += compute(el - 1, K - 1, 998244353)
		a %= 998244353
	print(a)


MOD = 998244353

def ncr(n, r):
	num = denom = 1
	for i in range(r):
		num = num * (n - i) % MOD
		denom = denom * (i + 1) % MOD
	return num * pow(denom, MOD - 2, MOD) % MOD
(N, K) = map(int, input().split())
if N < K:
	print(0)
elif K == 1:
	print(N)
else:
	ans = 0
	for i in range(1, N + 1):
		if N // i > K:
			ans += ncr(N // i - 1, K - 1)
			ans %= MOD
		elif N // i == K:
			ans += 1
			ans %= MOD
		else:
			break
	print(ans)


import sys
mod = 998244353
[n, k] = [int(i) for i in sys.stdin.readline().split()]

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a, m):
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
if k > n:
	print(0)
else:
	choose = [0 for i in range(n + 1)]
	choose[k - 1] = 1
	for i in range(k, n + 1):
		result = choose[i - 1]
		result *= i
		result = result % mod
		result *= modinv(i - (k - 1), mod)
		result = result % mod
		choose[i] = result
	ans = 0
	for i in range(1, n // k + 1):
		ans += choose[n // i - 1]
		ans = ans % mod
	print(ans)


p = 998244353
(n, k) = map(int, input().split())
(F, R) = ([1], [1])
for i in range(1, n + 1):
	F.append(F[i - 1] * i % p)
	R.append(pow(F[i], p - 2, p))
print(sum((F[n // i - 1] * R[k - 1] * R[n // i - k] % p for i in range(1, n + 1) if n - i >= (k - 1) * i)) % p)


import sys
input = sys.stdin.readline
import heapq
import copy
import math
import decimal
from decimal import *

class Node:

	def _init_(self, val):
		self.data = val
		self.left = None
		self.right = None

class fen_tree:

	def __init__(self, list):
		self.array = [0] + list
		for idx in range(1, len(self.array)):
			idx2 = idx + (idx & -idx)
			if idx2 < len(self.array):
				self.array[idx2] += self.array[idx]

	def prefix_query(self, idx):
		result = 0
		while idx:
			result += self.array[idx]
			idx -= idx & -idx
		return result

	def prints(self):
		print(self.array)
		return

	def range_query(self, from_idx, to_idx):
		return self.prefix_query(to_idx) - self.prefix_query(from_idx - 1)

	def update(self, idx, add):
		while idx < len(self.array):
			self.array[idx] += add
			idx += idx & -idx

def pre_sum(arr):
	p = [0]
	for i in arr:
		p.append(p[-1] + i)
	p.pop(0)
	return p

def pre_back(arr):
	p = [0]
	for i in arr:
		p.append(p[-1] + i)
	p.pop(0)
	return p

def bin_search(arr, l, r, val):
	if arr[r] <= val:
		return r + 1
	if r - l < 2:
		if arr[l] > val:
			return l
		else:
			return r
	mid = int((l + r) / 2)
	if arr[mid] <= val:
		return bin_search(arr, mid, r, val)
	else:
		return bin_search(arr, l, mid, val)

def search_leftmost(arr, val):

	def helper(arr, l, r, val):
		print(l, r)
		if arr[l] == val:
			return l
		if r - l <= 1:
			if arr[r] == val:
				return r
			else:
				print('not found')
				return
		mid = int((r + l) / 2)
		if arr[mid] >= val:
			return helper(arr, l, mid, val)
		else:
			return helper(arr, mid, r, val)
	return helper(arr, 0, len(arr) - 1, val)

def search_rightmost(arr, val):

	def helper(arr, l, r, val):
		print(l, r)
		if arr[r] == val:
			return r
		if r - l <= 1:
			if arr[l] == val:
				return r
			else:
				print('not found')
				return
		mid = int((r + l) / 2)
		if arr[mid] > val:
			return helper(arr, l, mid, val)
		else:
			return helper(arr, mid, r, val)
	return helper(arr, 0, len(arr) - 1, val)

def preorder_postorder(root, paths, parent, left, level):
	l = 0
	queue = [root]
	while queue != []:
		node = queue[-1]
		flag = 0
		for i in paths[node]:
			if i != parent[node] and level[i] == sys.maxsize:
				parent[i] = node
				level[i] = level[node] + 1
				flag = 1
				queue.append(i)
		if flag == 0:
			left[parent[node]] += 1 + left[node]
			queue.pop()
	return [parent, left, level]

def nCr(n, r, p):
	if r == 0:
		return 1
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def pr_list(a):
	print(*a, sep=' ')

def main():
	tests = 1
	mod = 998244353
	limit = 10 ** 18
	for test in range(tests):
		[n, k] = inlt()
		ans = 0
		a = math.ceil(n / k)
		for i in range(1, a + 1):
			curr = n // i
			if curr >= k:
				if curr == 1 and k == 1:
					ans = ans + 1
				elif curr > 1:
					dum = nCr(curr - 1, k - 1, mod)
					ans = (ans + dum) % mod
		print(int(ans))
main()


import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
from math import *
import copy
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def li():
	return [int(x) for x in input().split()]

def fi():
	return int(input())

def si():
	return list(input().rstrip())

def mi():
	return map(int, input().split())

def bo(i):
	return ord(i) - ord('a')

def mo(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
mod = 998244353
(n, k) = mi()
ft = [1 for i in range(n + 1)]
mt = [1 for i in range(n + 1)]
for i in range(1, n + 1):
	ft[i] = ft[i - 1] * i % mod
	mt[i] = mo(ft[i], mod)
if n < k:
	print(0)
	exit(0)
if k == 1:
	print(n)
	exit(0)
c = 0
for i in range(1, n):
	if n // i < k:
		break
	c = (c % mod + ft[n // i - 1] * mt[k - 1] * mt[n // i - k]) % mod
print(c)


import sys, math, os
from io import BytesIO, IOBase
from bisect import bisect_left as bl, bisect_right as br, insort
from collections import defaultdict as dd, deque, Counter

def data():
	return sys.stdin.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = 998244353

def main():
	fac = [1] * 500001
	for i in range(2, 500001):
		fac[i] = fac[i - 1] * i % mod
	(n, k) = mdata()
	fac = [1] * (n + 1)
	for i in range(2, n + 1):
		fac[i] = fac[i - 1] * i % mod
	ans = 0
	for i in range(1, n + 1):
		if n // i >= k:
			ans += fac[n // i - 1] * pow(fac[k - 1], mod - 2, mod) * pow(fac[n // i - k], mod - 2, mod) % mod
	out(ans % mod)
main()


import math
import sys
input = sys.stdin.readline
mod = 998244353
(n, k) = map(int, input().split())
fac = [0] * (n + 1)
inv = [0] * (n + 1)
inv[0] = fac[0] = 1
for i in range(1, n + 1):
	fac[i] = fac[i - 1] * i % mod
	inv[i] = pow(fac[i], mod - 2, mod)

def nCr(n, r):
	if n < 0 or n < r:
		return 0
	return fac[n] * inv[r] * inv[n - r] % mod
ans = 0
for i in range(1, n + 1):
	ans += nCr(n // i - 1, k - 1)
	ans %= mod
print(ans)


import sys
input = sys.stdin.readline
p = 998244353
pri = p
fac = [1 for i in range(5 * 10 ** 5 + 1)]
for i in range(2, len(fac)):
	fac[i] = fac[i - 1] * (i % pri) % pri

def modi(x):
	return pow(x, p - 2, p) % p

def ncr(n, r):
	x = fac[n] * (modi(fac[r]) % p * (modi(fac[n - r]) % p)) % p % p
	return x
(n, k) = map(int, input().split())
total = 0
for i in range(1, n // k + 1):
	total += ncr(n // i - 1, k - 1)
	total %= pri
print(total)


import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda : readline().rstrip()
ni = lambda : int(readline().rstrip())
nm = lambda : map(int, readline().split())
nl = lambda : list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
n_ = 5 * 10 ** 5 + 10
mod = 998244353
fun = [1] * (n_ + 1)
for i in range(1, n_ + 1):
	fun[i] = fun[i - 1] * i % mod
rev = [1] * (n_ + 1)
rev[n_] = pow(fun[n_], mod - 2, mod)
for i in range(n_ - 1, 0, -1):
	rev[i] = rev[i + 1] * (i + 1) % mod

def nCr(n, r):
	if r > n:
		return 0
	return fun[n] * rev[r] % mod * rev[n - r] % mod

def solve():
	(n, k) = nm()
	res = 0
	for i in range(1, n + 1):
		if i * k > n:
			break
		res = (res + nCr(n // i - 1, k - 1)) % mod
	print(res)
	return
solve()


import sys
import string
input = sys.stdin.readline
import math
from decimal import Decimal
n = list(map(int, input().split()))
(n, k) = (n[0], n[1])
m = 998244353
fact = []
fac = 1
for i in range(1, n + 2):
	fac *= i
	fac = fac % m
	fact.append(fac)
ans = 0
fact = [1] + fact
for i in range(1, n // k + 1):
	out = n // k
	a = n // i - 1
	b = k - 1
	l = fact[b] * fact[a - b]
	ans += fact[a] * pow(l, m - 2, m) % m
print(int(ans) % m)


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
mod = 998244353
fac = [1] * n
for i in range(1, n):
	fac[i] = i * fac[i - 1]
	fac[i] %= mod
i = 1
sol = 0
while (n - i) // i >= k - 1:
	mul = fac[(n - i) // i]
	div = fac[k - 1]
	div *= fac[1 + (n - i) // i - k]
	div %= mod
	s = pow(div, mod - 2, mod)
	s *= mul
	s %= mod
	sol += s
	sol %= mod
	i += 1
print(sol)


(n, k) = map(int, input().split())
mod = 998244353

def exp(number, n):
	res = 1
	while n != 0:
		if n & 1 == 1:
			res *= number
			res %= mod
			n -= 1
		number *= number
		number %= mod
		n >>= 1
	return res
fac = [1] * (n + 2)
for i in range(1, n + 1):
	fac[i] = fac[i - 1] * i
	fac[i] %= mod
fac2 = [fac[i] for i in range(n + 2)]
for i in range(n + 1):
	fac2[i] = exp(fac[i], mod - 2)
ans = 0
for i in range(1, n + 1):
	temp = n // i - 1
	if temp + 1 < k:
		break
	ans += fac[temp] * (fac2[temp - k + 1] * fac2[k - 1] % mod)
	ans %= mod
print(ans)


(n, k) = map(int, input().split())
m = 998244353
if n < k:
	print(0)
	quit()
factorials = [1 for i in range(n + 1)]
for i in range(1, n + 1):
	factorials[i] = factorials[i - 1] * i % m

def to_power(a, b, m):
	val = 1
	while b > 0:
		if b & 1 == 1:
			val = val * a % m
		a = a * a % m
		b = b >> 1
	return val
inverses = {}
k_1_inv = to_power(factorials[k - 1], m - 2, m)

def n_choose_k_mod_m(n, k, m, inverses):
	n_fac = factorials[n]
	n_k_fac = factorials[n - k]
	if n_k_fac in inverses:
		n_k_inv = inverses[n_k_fac]
	else:
		n_k_inv = to_power(n_k_fac, m - 2, m)
		inverses[n_k_fac] = n_k_inv
	return n_fac * k_1_inv * n_k_inv % m
cnt = 0
stored_values = {}
for i in range(1, n + 1):
	num_multiples = n // i - 1
	if num_multiples < k - 1:
		break
	else:
		if (num_multiples, k - 1) in stored_values:
			comb = stored_values[num_multiples, k - 1]
		else:
			comb = n_choose_k_mod_m(num_multiples, k - 1, m, inverses)
			stored_values[num_multiples, k - 1] = comb
		cnt = (cnt + comb) % m
print(cnt)


(n, k) = map(int, input().split())
(p, M, res) = ([1], 998244353, 0)
for i in range(1, 500001):
	p.append(p[-1] * i % M)

def c(m, n):
	return p[m] * pow(p[m - n] * p[n], M - 2, M) % M
for i in range(1, n + 1):
	if n // i < k:
		break
	res = (res + c(n // i - 1, k - 1)) % M
print(res)


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

def main():
	mod = 998244353
	inv = lambda x: pow(x, mod - 2, mod)
	(n, k) = map(int, input().split())
	if n < k:
		return 0
	Fact = [1]
	for i in range(1, n + 1):
		Fact.append(Fact[i - 1] * i % mod)
	Finv = [0] * (n + 1)
	Finv[-1] = inv(Fact[-1])
	for i in range(n - 1, -1, -1):
		Finv[i] = Finv[i + 1] * (i + 1) % mod

	def comb(n, r):
		if n < r:
			return 0
		return Fact[n] * Finv[r] * Finv[n - r] % mod
	ans = 0
	for a in range(1, n // k + 1):
		m = n // a
		ans += comb(m - 1, k - 1)
		ans %= mod
	return ans
print(main())


def choose(n, k, factorial, ifactorial):
	return factorial[n] * ifactorial[n - k] * ifactorial[k] % 998244353

def prog():
	(n, k) = map(int, input().split())
	factorial = [1]
	for i in range(1, n + 1):
		factorial.append(factorial[-1] * i % 998244353)
	ifactorial = [1 for i in range(n + 1)]
	curr = pow(factorial[n], 998244353 - 2, 998244353)
	for i in range(n, 0, -1):
		ifactorial[i] = curr
		curr = curr * i % 998244353
	tot_stable = 0
	for smallest in range(1, int(n / k) + 1):
		tot_stable += choose(n // smallest - 1, k - 1, factorial, ifactorial)
	print(tot_stable % 998244353)
prog()


fact = [1]
for i in range(1, 500001):
	fact.append(fact[i - 1] * i)
	fact[i] = fact[i] % 998244353
(n, k) = [int(x) for x in input().split()]
if k > n:
	print(0)
else:
	m = 998244353
	count = 1
	ans = 0
	while True:
		x = n // count
		if x < k:
			break
		x -= 1
		ans += fact[x] * pow(fact[x - k + 1], m - 2, m) * pow(fact[k - 1], m - 2, m) % m
		ans = ans % m
		count += 1
	print(ans)


(n, k) = map(int, input().split())
mod = 998244353
rng = 500100
fctr = [1]
for i in range(1, rng):
	fctr.append(fctr[-1] * i % mod)

def finv(x):
	return pow(fctr[x], mod - 2, mod)

def cmb(n, k):
	if n < 0 or k < 0:
		return 0
	else:
		return fctr[n] * finv(n - k) * finv(k) % mod
if n < k:
	print(0)
	exit()
ans = 0
for i in range(1, n + 1):
	t = n // i
	if n // i >= k:
		ans += cmb(t - 1, k - 1)
		ans %= mod
print(ans)


MOD = 998244353
OBRAT = {}
CC = {}
FACT = [-1] * 500001
OBRAT_FACT = [-1] * 500001

def obrat(k):
	if k not in OBRAT:
		OBRAT[k] = fast_pow(k, MOD - 2)
	return OBRAT[k]

def c(n, k):
	k = min(k, n - k)
	if (n, k) in CC:
		return CC[n, k]
	nn = 1
	for i in range(n - k + 1, n + 1):
		nn = nn * i % MOD
	kk = 1
	for t in range(1, k + 1):
		kk = kk * obrat(t) % MOD
	res = nn * kk % MOD
	CC[n, k] = res
	return res

def obrat_fact(k):
	if OBRAT_FACT[k] != -1:
		return OBRAT_FACT[k]
	res = 1
	for i in range(2, k + 1):
		res = res * obrat(i) % MOD
	OBRAT_FACT[k] = res
	return res

def fact(n):
	if FACT[n] != -1:
		return FACT[n]
	res = 1
	for i in range(2, n + 1):
		res = res * i % MOD
	FACT[n] = res
	return res

def fast_pow(x, y):
	if y == 0:
		return 1
	p = fast_pow(x, y // 2) % MOD
	p = p * p % MOD
	if y % 2:
		p = p * x % MOD
	return p
(n, k) = list(map(int, input().split()))
if k == 1:
	print(n)
	exit()
ans = 0
for i in range(1, n + 1):
	if n // i >= k:
		ans = (ans + c(n // i - 1, k - 1)) % MOD
print(ans)


MOD = 998244353
MAX = 5 * 10 ** 5 + 10
pre_mod = [1 for i in range(MAX)]
pre_inv_mod = [1] * MAX
(pre_mod[0], pre_mod[1]) = (1, 1)
for i in range(2, MAX):
	pre_mod[i] = pre_mod[i - 1] * i % MOD
pre_inv_mod[-1] = pow(pre_mod[-1], MOD - 2, MOD)
for i in range(MAX - 2, 0, -1):
	pre_inv_mod[i] = pre_inv_mod[i + 1] * (i + 1) % MOD

def ncr(n, r):
	if n < r or r < 0 or n < 0:
		return 0
	return pre_mod[n] * pre_inv_mod[r] % MOD * pre_inv_mod[n - r] % MOD

def solve(n, k):
	ans = 0
	for lo in range(1, n + 1):
		options = n // lo - 1
		need_to_take = k - 1
		ans += ncr(options, need_to_take)
		ans %= MOD
	return ans
(n, k) = map(int, input().split())
ncr(6, 2)
print(solve(n, k))


mod = 998244353
F = [1]
(n, m) = map(int, input().split())
for i in range(1, n + 1):
	F.append(F[i - 1] * i % mod)
Ans = 0
for mi in range(1, n + 1):
	k = (n - mi) // mi
	if k >= m - 1:
		Ans += F[k] * pow(F[m - 1], mod - 2, mod) % mod * pow(F[k - m + 1], mod - 2, mod) % mod
		Ans %= mod
	else:
		break
print(Ans)


(n, k) = map(int, input().split())
from math import factorial
if n < k:
	print(0)
else:
	ans = 0
	m = 998244353

	def ncr(n, r, p):
		num = den = 1
		for i in range(r):
			num = num * (n - i) % p
			den = den * (i + 1) % p
		return num * pow(den, p - 2, p) % p
	if k == 1:
		print(n)
	else:
		for i in range(1, n):
			if n // i > k:
				ans += ncr(n // i - 1, k - 1, m)
				ans %= m
			elif n // i == k:
				ans += 1
				ans %= m
			else:
				break
		print(ans)


(n, k) = map(int, input().split())
mod = 998244353
fact = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, n + 5):
	fact.append(fact[-1] * i % mod)
	inv.append(inv[mod % i] * (mod - mod // i) % mod)
	finv.append(finv[-1] * inv[-1] % mod)

def nCr(n, r, mod):
	if r > n:
		return 0
	else:
		return fact[n] * finv[r] * finv[n - r] % mod

def nPr(n, r, mod):
	if r > n:
		return 0
	else:
		return fact[n] * finv[n - r] % mod
ans = 0
for i in range(1, n + 1):
	x = n // i
	if x >= k:
		ans += nCr(x - 1, k - 1, mod)
		ans %= mod
	else:
		break
print(ans)


import time
import math
inp = input().rstrip().split()
(n, k) = (int(inp[0]), int(inp[1]))
MOD = 998244353

def C(n, k):
	if k > n:
		return 0
	elif n == 0 and k == 0:
		return 1
	else:
		return fact[n] * inv(fact[k] * fact[n - k], MOD) % MOD
ans = 0

def extendedGCD(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(d1, x1, y1) = extendedGCD(b % a, a)
		new_x = y1 - b // a * x1
		new_y = x1
		return (d1, new_x, new_y)

def inv(b, m):
	(d, x, y) = extendedGCD(b, m)
	return (x % m + m) % m
fact = {}
fact[0] = 1
i = 1
prod = 1
while i <= n:
	prod = prod * i % MOD
	fact[i] = prod
	i += 1
m = 1
upper_limit = math.floor(n * 1.0 / k)
while m <= upper_limit:
	ans += C(math.floor(n / m) - 1, k - 1)
	ans = ans % MOD
	m += 1
print(ans)


import sys
INF = 10 ** 20
MOD = 998244353
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(n, k) = I()
f = [1] * (n + 1)
for i in range(1, n + 1):
	f[i] = f[i - 1] * i
	f[i] %= MOD
if k > n:
	print(0)
	exit()

def inv(x):
	return pow(x, MOD - 2, MOD)

def nCr(n, r):
	if r > n:
		return 0
	return f[n] * inv(f[n - r]) * inv(f[r]) % MOD
ans = 0
for i in range(1, n + 1):
	ok = n // i
	ans += nCr(ok - 1, k - 1)
	ans %= MOD
print(ans)


(n, k) = map(int, input().split())
M = 998244353
ft = [1] * 500001
for i in range(1, 500001):
	ft[i] = ft[i - 1] * i % M
ans = 0
for i in range(1, n + 1):
	a = n // i - 1
	if a < k - 1:
		break
	ans = (ans + ft[a] * pow(ft[k - 1] * ft[a - k + 1], M - 2, M)) % M
print(ans)


(n, k) = map(int, input().split())
mod = 998244353
g1 = [1, 1]
g2 = [1, 1]
inv = [0, 1]
for i in range(2, n + 1):
	g1.append(g1[-1] * i % mod)
	inv.append(-inv[mod % i] * (mod // i) % mod)
	g2.append(g2[-1] * inv[-1] % mod)

def comb(n, r):
	if r < 0 or r > n:
		return 0
	return g1[n] * g2[r] * g2[n - r] % mod
ans = 0
for i in range(1, n + 1):
	ans += comb(n // i - 1, k - 1)
print(ans % mod)


(n, k) = map(int, input().split())
mod = 998244353
f = [1]
for i in range(n):
	f += [f[-1] * (i + 1) % mod]

def comb(a, b):
	return f[a] * pow(f[b], mod - 2, mod) * pow(f[a - b], mod - 2, mod) % mod
ans = 0
for i in range(1, n + 1):
	m = n // i - 1
	if m < k - 1:
		break
	ans += comb(m, k - 1)
	ans %= mod
print(ans)


(n, k) = map(int, input().split())
MOD = 998244353
fact = [1] * (n + 1)
for i in range(2, n + 1):
	fact[i] = fact[i - 1] * i % MOD
ifact = [1] * (n + 1)
ifact[n] = pow(fact[n], MOD - 2, MOD)
for i in range(n, 0, -1):
	ifact[i - 1] = ifact[i] * i % MOD

def choose(n, k):
	return fact[n] * ifact[n - k] * ifact[k] % MOD
r = 0
for m in range(1, n + 1):
	div = n // m
	if div < k:
		break
	r = (r + choose(div - 1, k - 1)) % MOD
print(r)


from math import sqrt
(n, k) = [int(x) for x in input().split()]
if n // k > 500:
	modNum = 998244353

	def choose(n, k):
		if k >= n:
			return 1
		base = 1
		div = min(k, n - k)
		for x in range(1, div + 1):
			base *= n
			base //= x
			n -= 1
		return base % 998244353
	out = 0
	for a in range(n // k):
		start = a + 1
		amt = n // start
		out += choose(amt - 1, k - 1)
	print(out % modNum)
else:
	primes = [2]
	for num in range(3, n + 1, 2):
		sq = sqrt(num)
		valid = True
		for a in primes:
			if num % a == 0:
				valid = False
				break
			if a > sq:
				break
		if valid:
			primes.append(num)

	def factored(n, primes):
		counts = {x: 0 for x in primes}
		for a in primes:
			base = a
			while base <= n:
				counts[a] += n // base
				base *= a
		return counts
	modNum = 998244353
	out = 0
	for a in range(n // k):
		start = a + 1
		amt = n // start
		first = factored(amt - 1, primes)
		second = factored(k - 1, primes)
		third = factored(amt - k, primes)
		thing = {x: first[x] - second[x] - third[x] for x in primes}
		base = 1
		for x in thing:
			for y in range(thing[x]):
				base *= x
				base = base % 998244353
		out += base
	print(out % modNum)


from bisect import *
from collections import *
from math import gcd, ceil, sqrt, floor, inf
from heapq import *
from itertools import *
from operator import add, mul, sub, xor, truediv, floordiv
from functools import *
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
farr = [1]
ifa = []

def fact(x, mod=0):
	if mod:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr) % mod)
	else:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr))
	return farr[x]

def ifact(x, mod):
	global ifa
	ifa.append(pow(farr[-1], mod - 2, mod))
	for i in range(x, 0, -1):
		ifa.append(ifa[-1] * i % mod)
	ifa = ifa[::-1]

def per(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return fact(i) // fact(i - j)
	return farr[i] * ifa[i - j] % mod

def com(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return per(i, j) // fact(j)
	return per(i, j, mod) * ifa[j] % mod

def catalan(n):
	return com(2 * n, n) // (n + 1)

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def lowbit(n):
	return n & -n

def inverse(a, m):
	a %= m
	if a <= 1:
		return a
	return (1 - inverse(m, a) * m) // a % m

class BIT:

	def __init__(self, arr):
		self.arr = arr
		self.n = len(arr) - 1

	def update(self, x, v):
		while x <= self.n:
			self.arr[x] += v
			x += x & -x

	def query(self, x):
		ans = 0
		while x:
			ans += self.arr[x]
			x &= x - 1
		return ans

class DSU:

	def __init__(self, n):
		self.c = [-1] * n

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def find(self, x):
		if self.c[x] < 0:
			return x
		self.c[x] = self.find(self.c[x])
		return self.c[x]

	def union(self, u, v):
		(u, v) = (self.find(u), self.find(v))
		if u == v:
			return False
		if self.c[u] < self.c[v]:
			(u, v) = (v, u)
		self.c[u] += self.c[v]
		self.c[v] = u
		return True

	def size(self, x):
		return -self.c[self.find(x)]

class UFS:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv

def Prime(n):
	c = 0
	prime = []
	flag = [0] * (n + 1)
	for i in range(2, n + 1):
		if not flag[i]:
			prime.append(i)
			c += 1
		for j in range(c):
			if i * prime[j] > n:
				break
			flag[i * prime[j]] = prime[j]
			if i % prime[j] == 0:
				break
	return flag

def dij(s, graph):
	d = {}
	d[s] = 0
	heap = [(0, s)]
	seen = set()
	while heap:
		(dis, u) = heappop(heap)
		if u in seen:
			continue
		for v in graph[u]:
			if v not in d or d[v] > d[u] + graph[u][v]:
				d[v] = d[u] + graph[u][v]
				heappush(heap, (d[v], v))
	return d

def GP(it):
	return [[ch, len(list(g))] for (ch, g) in groupby(it)]

class DLN:

	def __init__(self, val):
		self.val = val
		self.pre = None
		self.next = None

def nb(i, j):
	for (ni, nj) in [[i + 1, j], [i - 1, j], [i, j - 1], [i, j + 1]]:
		if 0 <= ni < n and 0 <= nj < m:
			yield (ni, nj)

@bootstrap
def gdfs(r, p):
	if len(g[r]) == 1 and p != -1:
		yield None
	for ch in g[r]:
		if ch != p:
			yield gdfs(ch, r)
	yield None
t = 1
for i in range(t):
	(n, k) = RL()
	mod = 998244353
	ans = 0
	fact(n, mod)
	ifact(n, mod)
	for i in range(1, n + 1):
		c = n // i
		if c < k:
			break
		ans += com(c - 1, k - 1, mod)
		ans %= mod
	print(ans)


def pow3(a, b, mod):
	ans = 1
	while b > 0:
		if b & 1:
			ans = ans * a % mod
		a = a * a % mod
		b >>= 1
	return ans

class comb:
	inf = 0
	fact = []
	inv = []

	def __init__(self, n, infi):
		self.fact.extend([0] * (n + 1))
		self.inv.extend([0] * (n + 1))
		self.inf = infi
		self.fact[0] = 1
		for i in range(1, n + 1):
			self.fact[i] = self.fact[i - 1] * i % self.inf
		for i in range(0, n + 1):
			self.inv[i] = pow3(self.fact[i], self.inf - 2, self.inf)

	def ncr(self, n, r):
		ans = self.fact[n]
		ans = ans * self.inv[r] % inf
		ans = ans * self.inv[n - r] % inf
		return ans

	def f(self, n):
		return self.fact[n]

	def iv(self, n):
		return self.ivf[n]
inf = 998244353
(n, k) = list(map(int, input().split()))
c1 = comb(n, inf)
ans = 0
i = 1
while i * k <= n:
	cnt = n // i - 1
	r = k - 1
	ans = (ans + c1.ncr(cnt, r)) % inf
	i += 1
print(ans)


(n, k) = map(int, input().split())
p = 998244353

def pot(a, d):
	res = 1
	mno = a
	while d > 0:
		if d % 2 == 1:
			res = res * mno % p
		mno = mno * mno % p
		d //= 2
	return res
silnia = [1] * (n + 1)
for i in range(2, n + 1):
	silnia[i] = i * silnia[i - 1] % p
wyn = 0
for a1 in range(1, n + 1):
	if n // a1 < k:
		break
	else:
		zb = n // a1 - 1
		wyn += silnia[zb] * pot(silnia[zb - k + 1], p - 2) * pot(silnia[k - 1], p - 2)
print(wyn % p)


def ncr(n, r):
	num = fac[n]
	den1 = fac[r]
	den2 = fac[n - r]
	ret = num * pow(den1, 998244353 - 2, 998244353) % 998244353
	return ret * pow(den2, 998244353 - 2, 998244353) % 998244353
(n, k) = map(int, input().split())
fac = [1]
for x in range(1, n + 1):
	fac.append(x * fac[-1] % 998244353)
ans = 0
for x in range(1, n - k + 2):
	a = n // x - 1
	b = k - 1
	if b > a:
		break
	ans = (ans + ncr(a, b)) % 998244353
print(ans)


import sys
input = sys.stdin.buffer.readline
M = 998244353
(n, k) = map(int, input().split())
p = list(range(n + 1))
p[0] = 1
for i in range(1, n + 1):
	p[i] *= p[i - 1]
	p[i] %= M
cc = 0
for u in range(1, n + 1):
	c = n // u
	if c < k:
		continue
	cc += p[c - 1] * pow(p[k - 1] * p[c - k], M - 2, M)
	cc %= M
print(cc)


MOD = 998244353
fact = [1]
curr = 1
for i in range(1, 6 * 10 ** 5):
	curr *= i
	curr %= MOD
	fact.append(curr)

def inv(x):
	return pow(x, MOD - 2, MOD)
(n, k) = map(int, input().split())
out = 0
for i in range(1, n + 1):
	count = n // i - 1
	if count >= k - 1:
		binom = fact[count]
		binom *= inv(fact[k - 1])
		binom %= MOD
		binom *= inv(fact[count - k + 1])
		binom %= MOD
		out += binom
		out %= MOD
print(out)


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
mod = 998244353
FACT = [1]
for i in range(1, 6 * 10 ** 5 + 1):
	FACT.append(FACT[-1] * i % mod)
FACT_INV = [pow(FACT[-1], mod - 2, mod)]
for i in range(6 * 10 ** 5, 0, -1):
	FACT_INV.append(FACT_INV[-1] * i % mod)
FACT_INV.reverse()

def Combi(a, b):
	if 0 <= b <= a:
		return FACT[a] * FACT_INV[b] * FACT_INV[a - b] % mod
	else:
		return 0
if k == 1:
	print(n)
	sys.exit()
ANS = 0
for i in range(1, n + 1):
	x = n // i
	if x <= 1:
		break
	ANS = (ANS + Combi(x - 1, k - 1)) % mod
print(ANS)


mod = 998244353

def func(n, k):
	return fact[n] * pow(fact[k] * fact[n - k] % mod, mod - 2, mod) % mod
(n, k) = map(int, input().split())
if k == 1:
	print(n)
	exit(0)
fact = [1]
for i in range(1, 1000001):
	fact.append(fact[-1] * i % mod)
if k > n:
	print(0)
elif k == n:
	print(1)
else:
	ans = func(n - 1, k - 1)
	temp = n // k
	for i in range(2, temp + 1):
		count = n // i
		ans += func(count - 1, k - 1)
		ans = ans % mod
	print(ans)


import io
import os
from collections import Counter, defaultdict, deque
from itertools import combinations, permutations
from functools import reduce
MOD = 998244353

def modInverse(a, p):
	return pow(a, p - 2, p)
fact = [1]
for i in range(1, 5 * 10 ** 5 + 1):
	fact.append(fact[-1] * i % MOD)

def nCr(n, r, p=MOD):
	return fact[n] * modInverse(fact[r], p) * modInverse(fact[n - r], p) % p

def solve(N, K):
	if K > N:
		return 0
	if K == N:
		return 1
	if K == 1:
		return N
	ans = 0
	for mn in range(1, N + 1):
		numMultiples = N // mn
		if numMultiples >= K:
			ans += nCr(numMultiples - 1, K - 1)
			ans %= MOD
	return ans % MOD
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N, K) = [int(x) for x in input().split()]
ans = solve(N, K)
print(ans)