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: interview

Starter code:

Solutions:

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)

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 = list(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
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)

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 = list(map(int, input().split()))
ans = 0
for i in range(n):
    ans += nCr(n // (i + 1) - 1, k - 1)
print(ans % MOD)


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()

# T = ni()
# for _ in range(T):
#     solve()


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 the first number is i, then the remainder is an increasing sequence from
    # [2*i, 3*i, ..., n] or equivalently an inc seq from [1, ..., n//i - 1] of
    # length k-1. That is, it's binom(n//i - 1, k-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 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()