CodeEff/ECCO huggingface dataset:
# Original solution
import bisect
import heapq
import sys
import itertools
import queue


input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7


class V:
    def __init__(self, f):
        self.f = f
        self.v = None

    def __str__(self):
        return str(self.v)

    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n)

    def get(self):
        return self.v


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


def read_list():
    return list(read_values())


def P(N):
    D = []
    for n in range(1, int(N ** 0.5) + 1):
        D.append(n)
        if N // n != n:
            D.append(N // n)
    D.sort()
    return D


def main():
    N, K = read_values()
    D = P(N)
    C = [D[i] - D[i - 1] if i != 0 else D[i] for i, d in enumerate(D)]
    dp = {}
    SS = [[0] + D] + [[0] * (len(D) + 1) for k in range(K - 1)]

    for k in range(1, K):
        for i, d in enumerate(D):
            j = bisect.bisect_left(D, N // d)
            dp[d] = (SS[k - 1][j + 1] * C[i]) % mod
            SS[k][i + 1] = (SS[k][i] + dp[d]) % mod
    print((sum(dp.values()) % mod))


if __name__ == "__main__":
    main()


# Optimized solution
import bisect
import heapq
import sys
import itertools
import queue


input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7


class V:
    def __init__(self, f):
        self.f = f
        self.v = None

    def __str__(self):
        return str(self.v)

    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n)

    def get(self):
        return self.v


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


def read_list():
    return list(read_values())


def P(N):
    D = []
    for n in range(1, int(N ** 0.5) + 1):
        D.append(n)
        if N // n != n:
            D.append(N // n)
    D.sort()
    return D


def main():
    N, K = read_values()
    D = P(N)
    C = [(D[i] - D[i - 1]) % mod if i != 0 else D[i] for i, d in enumerate(D)]
    dp = [0] * len(D)
    S = [D] + [[0] * len(D) for k in range(K - 1)]
    I = [bisect.bisect_left(D, N // d) for d in D]

    for k in range(1, K):
        for i in range(len(D)):
            j = I[i]
            dp[i] = (S[k - 1][j] * C[i]) % mod
            S[k][i] = (S[k][i - 1] + dp[i]) % mod
    print((S[-1][-1] % mod))


if __name__ == "__main__":
    main()
# Original solution
import sys
from bisect import bisect_left as bl
input = sys.stdin.readline
N, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
h = 1
t = set()
while h * h <= N:
  t.add(N // h)
  t.add(h)
  h += 1
t = sorted(t)
#print(t)
tt = []
for x in t:
  tt.append(N // x)

dp = [[0] * len(t) for _ in range(K + 1)]
dp[0][0] = 1
for i in range(K):
  for j in range(len(t)):
    k = bl(t, tt[j])
    dp[i + 1][k] += dp[i][j]
    dp[i + 1][k] %= mod
  #print(dp)
  for k in range(len(t) - 1, 0, -1):
    dp[i + 1][k - 1] += dp[i + 1][k]
    dp[i + 1][k - 1] %= mod
  for k in range(1, len(t)):
    rng = (t[k] - t[k - 1]) % mod
    dp[i + 1][k] *= rng
    dp[i + 1][k] %= mod
  #print(dp)
res = 0
#print(dp)
for j in range(len(t)):
  res += dp[-1][j]
  res %= mod
print(res)

# Optimized solution
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
h = 1
t = set()
while h * h <= N:
  t.add(N // h)
  t.add(h)
  h += 1
t = sorted(t)
#print(len(t))
tt = []
for x in t:
  tt.append(N // x)

dp = [[0] * len(t) for _ in range(K + 1)]
dp[0][0] = 1
for i in range(K):
  for j in range(len(t)):
    k = len(t) - j - 1
    dp[i + 1][k] += dp[i][j]
    dp[i + 1][k] %= mod
  #print(dp)
  for k in range(len(t) - 1, 0, -1):
    dp[i + 1][k - 1] += dp[i + 1][k]
    dp[i + 1][k - 1] %= mod
    rng = (t[k] - t[k - 1]) % mod
    dp[i + 1][k] *= rng
    dp[i + 1][k] %= mod

  #print(dp)
res = 0
#print(dp)
for j in range(len(t)):
  res += dp[-1][j]
  res %= mod
print(res)
# Original solution
import math
from bisect import bisect_left

MOD = 10**9 + 7


def main():
    N, K = list(map(int, input().split()))
    R = int(math.sqrt(N))
    if N // R == R:
        M = R * 2 - 1
    else:
        M = R * 2
    mapping = [0] * (M+1)
    for i in range(1, R+1):
        mapping[i] = i
        mapping[-i] = N//i
    cnt = [0] * (M+1)
    for i in range(1, M+1):
        cnt[i] = mapping[i] - mapping[i-1]
    dp = [[0] * (M+1) for _ in range(K+1)]
    dp[0] = list(cnt)
    for i in range(M):
        dp[0][i+1] += dp[0][i]

    for i in range(K-1):
        for j in range(1, M+1):
            v = N // mapping[j]
            idx = bisect_left(mapping, v)
            dp[i+1][j] = dp[i][idx]
        for j in range(M):
            dp[i+1][j+1] = (dp[i+1][j] + dp[i+1][j+1] * cnt[j+1]) % MOD
    print((dp[K-1][M]))


if __name__ == "__main__":
    main()


# Optimized solution
import math

MOD = 10**9 + 7


def main():
    N, K = list(map(int, input().split()))
    R = int(math.sqrt(N))
    if N // R == R:
        M = R * 2 - 1
    else:
        M = R * 2
    mapping = [0] * (M+1)
    for i in range(1, R+1):
        mapping[i] = i
        mapping[-i] = N//i
    cnt = [0] * (M+1)
    for i in range(1, M+1):
        cnt[i] = mapping[i] - mapping[i-1]
    dp = [[0] * (M+1) for _ in range(K+1)]
    dp[0] = list(cnt)
    for i in range(M):
        dp[0][i+1] += dp[0][i]

    for i in range(K-1):
        for j in range(1, M+1):
            if j <= R:
                idx = -j
            else:
                idx = M - j + 1
            dp[i+1][j] = dp[i][idx]
        for j in range(M):
            dp[i+1][j+1] = (dp[i+1][j] + dp[i+1][j+1] * cnt[j+1]) % MOD
    print((dp[K-1][M]))


if __name__ == "__main__":
    main()
# Original solution
from bisect import bisect
mod = 10**9+7
N,K = list(map(int,input().split()))

c = []
for i in range(1,int(N**0.5)+1):
    c.append(i)
    c.append(int(N/i))
c = list(set(c))
c.sort()

k = []
for i in c:
    if int(N/i) != int(N/(i+1)):
        k.append(i)

dp = [[0]*len(k) for _ in range(K)]
for i in range(len(k)):
    dp[0][i]=k[i]

def S(n,m):
    l = bisect(k,m)
    return dp[n][l-1]+(dp[n][l]-dp[n][l-1])*(m-k[l-1])*pow(k[l]-k[l-1],mod-2,mod)

    
for i in range(K-1):
    dp[i+1][0] = dp[i][-1]
    for j in range(len(k)-1):
        dp[i+1][j+1] = dp[i+1][j]+(k[j+1]-k[j])*S(i,int(N/(k[j]+1)))
        dp[i+1][j+1] %= mod

print((dp[-1][-1]))

# Optimized solution
from bisect import bisect
mod = 10**9+7
N,K = list(map(int,input().split()))

c = []
for i in range(1,int(N**0.5)+1):
    c.append(i)
    c.append(int(N/i))
c = list(set(c))
c.sort()

k = []
for i in c:
    if int(N/i) != int(N/(i+1)):
        k.append(i)

dp = [[0]*len(k) for _ in range(K)]
for i in range(len(k)):
    dp[0][i]=k[i]

inv = [0]*(len(k)-1)
for i in range(len(k)-1):
    inv[i] = pow(k[i+1]-k[i],mod-2,mod)

index = [0]*len(k)
for i in range(len(k)):
    m = int(N/(k[i]+1))
    index[i] = bisect(k,m)

for i in range(K-1):
    dp[i+1][0] = dp[i][-1]
    for j in range(len(k)-1):
        m = int(N/(k[j]+1))
        l = index[j]
        S = dp[i][l-1]+(dp[i][l]-dp[i][l-1])*(m-k[l-1])*inv[l-1]
        dp[i+1][j+1] = dp[i+1][j]+(k[j+1]-k[j])*S
        dp[i+1][j+1] %= mod

print((dp[-1][-1]))
# Original solution
from bisect import bisect
mod = 10**9+7
N,K = list(map(int,input().split()))

c = []
for i in range(1,int(N**0.5)+1):
    c.append(i)
    c.append(int(N/i))
c = list(set(c))
c.sort()

k = []
for i in c:
    if int(N/i) != int(N/(i+1)):
        k.append(i)

dp = [[0]*len(k) for _ in range(K)]
for i in range(len(k)):
    dp[0][i]=k[i]

inv = [0]*(len(k)-1)
for i in range(len(k)-1):
    inv[i] = pow(k[i+1]-k[i],mod-2,mod)

index = [0]*len(k)
for i in range(len(k)):
    m = int(N/(k[i]+1))
    index[i] = bisect(k,m)

for i in range(K-1):
    dp[i+1][0] = dp[i][-1]
    for j in range(len(k)-1):
        m = int(N/(k[j]+1))
        l = index[j]
        S = dp[i][l-1]+(dp[i][l]-dp[i][l-1])*(m-k[l-1])*inv[l-1]
        dp[i+1][j+1] = dp[i+1][j]+(k[j+1]-k[j])*S
        dp[i+1][j+1] %= mod

print((dp[-1][-1]))

# Optimized solution
mod = 10**9+7
N,K = list(map(int,input().split()))
M = int(N**0.5)
dp = [[0]*M for _ in range(K+1)]
dp1 = [[0]*M for _ in range(K+1)]
dp2 = [[0]*M for _ in range(K+1)]

dp[0][0] = 1
dp1[0][0] = 1
dp2[0][0] = N
for m in range(1,M):
    dp[0][m] = 1
    dp1[0][m] = dp1[0][m-1]+dp[0][m]
    dp2[0][m] += dp2[0][m-1]+N//(m+1)*dp[0][m]

dp[1][0] = N
dp1[1][0] = N
dp2[1][0] = N**2
for m in range(1,M):
    dp[1][m] = N//(m+1)
    dp1[1][m] = dp1[1][m-1]+dp[1][m]
    dp2[1][m] += dp2[1][m-1]+N//(m+1)*dp[1][m]


for k in range(1,K):
    for m in range(M):
        dp[k+1][m] = dp1[k][M-1]+N//(m+1)*dp1[k-1][m]+dp2[k-1][M-1]-dp2[k-1][m]-M*dp1[k-1][M-1]
        dp[k+1][m] %= mod
        dp1[k+1][m] = dp1[k+1][m-1]+dp[k+1][m]
        dp1[k+1][m] %= mod
        dp2[k+1][m] = dp2[k+1][m-1]+N//(m+1)*dp[k+1][m]
        dp2[k+1][m] %= mod

print((dp[K][0]))
# Original solution
import sys
sys.setrecursionlimit(10**6)
N, K = list(map(int, input().split()))
MOD = 10**9 + 7

U = [0]
V = []
for x in range(1, int(N**.5)+1):
    U.append(x)
    if x < N//x:
        V.append(N//x)
V.reverse()
U.extend(V)

L = len(U)
memo = {(K, e): 1 for e in U}
for k in range(K-1, -1, -1):
    memo[k, 0] = 0
    r = 0
    for x, y in zip(U, U[1:]):
        memo[k, y] = r = ((y - x) * memo[k+1, N//y] + r) % MOD
print((memo[0, N]))

# Optimized solution
import sys
sys.setrecursionlimit(10**6)
N, K = list(map(int, input().split()))
MOD = 10**9 + 7

U = [0]; V = []
for x in range(1, int(N**.5)+1):
    U.append(x)
    if x < N//x:
        V.append(N//x)
V.reverse(); U.extend(V)

L = len(U)
S = [1]*L
S[0] = 0
for k in range(K-1, -1, -1):
    T = [0]*L
    r = 0
    for i in range(1, L):
        x = U[i-1]; y = U[i]
        T[i] = r = ((y - x) * S[L-i] + r) % MOD
    S = T
print((S[-1]))
# Original solution
def f(n,k):
    lim = int((n + 0.1) ** 0.5) + 1
    ws = []
    s = 0
    for i in range(1, lim):
        w = n // i - n // (i + 1)
        ws.append(w)
        s += w
    ws += [1] * (n - s)
    m = len(ws)
    dp0 = ws[::-1]
    dp1 = [0] * m
    for _ in range(k - 1):
        s = 0
        for j in range(m):
            s += dp0[j]
            dp1[m - j - 1] = (s * ws[j]) % md
        dp0 = dp1[:]
    print((sum(dp0) % md))
md=10**9+7
n,k=list(map(int,input().split()))
f(n,k)


# Optimized solution
from itertools import accumulate

def f(n,k):
    lim = int((n + 0.1) ** 0.5) + 1
    ws = []
    s = 0
    for i in range(1, lim):
        w = n // i - n // (i + 1)
        ws.append(w)
        s += w
    ws += [1] * (n - s)
    dp=ws
    m = len(ws)
    for _ in range(k - 1):
        dp=[s*w%md for s,w in zip(accumulate(dp[::-1]),ws)]
    print((sum(dp) % md))
md=10**9+7
n,k=list(map(int,input().split()))
f(n,k)
# Original solution
import math
import os
import sys
from collections import defaultdict
from functools import lru_cache

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

MOD = 10 ** 9 + 7
N, K = list(map(int, sys.stdin.readline().split()))


@lru_cache(maxsize=None)
def next_max(n):
    # ある数と隣り合わせになれる数
    return int(N // n)


NM = []
prev = 0
for i in range(1, int(math.sqrt(N)) + 2):
    NM.append(N - next_max(i) - prev)
    prev = (N - next_max(i))


@lru_cache(maxsize=None)
def rec(n, k):
    if n <= 0:
        return 0
    if k <= 1:
        return n

    i = next_max(n)
    p = NM[i] if i < len(NM) else 1
    ret = rec(i, k - 1) * p % MOD
    cum = rec(n - p, k)
    return (cum + ret) % MOD


cnt = N
nums = []
while cnt >= 1:
    nums.append(cnt)
    i = next_max(cnt)
    p = NM[i] if i < len(NM) else 1
    cnt -= p
nums.reverse()

# dp[k][n]: rec(n, k)
dp = defaultdict(lambda: defaultdict(int))
for n in nums:
    dp[1][n] = n
for k in range(2, K+1):
    for n in nums:
        i = next_max(n)
        p = NM[i] if i < len(NM) else 1
        ret = dp[k - 1][i] * p % MOD
        cum = dp[k][n - p]
        dp[k][n] = (cum + ret) % MOD

ans = dp[K][N]
print((ans % MOD))

# ans = rec(N, K)
# print(ans % MOD)


# Optimized solution
import math
import os
import sys
from collections import defaultdict

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

MOD = 10 ** 9 + 7
N, K = list(map(int, sys.stdin.readline().split()))

NM = []
prev = 0
for i in range(1, int(math.sqrt(N)) + 2):
    m = int(N // i)
    NM.append(N - m - prev)
    prev = N - m

cnt = N
nums = []
while cnt >= 1:
    nums.append(cnt)
    i = int(N // cnt)
    p = NM[i] if i < len(NM) else 1
    cnt -= p
nums.reverse()

# dp[k][n]: rec(n, k)
dp = defaultdict(lambda: defaultdict(int))
for n in nums:
    dp[1][n] = n
for k in range(2, K + 1):
    for n in nums:
        i = int(N // n)
        p = NM[i] if i < len(NM) else 1
        ret = dp[k - 1][i] * p % MOD
        cum = dp[k][n - p]
        dp[k][n] = (cum + ret) % MOD

ans = dp[K][N]
print((ans % MOD))

# ans = rec(N, K)
# print(ans % MOD)
# Original solution
import math
import os
import sys
from collections import defaultdict

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

MOD = 10 ** 9 + 7
N, K = list(map(int, sys.stdin.readline().split()))

NM = []
prev = 0
for i in range(1, int(math.sqrt(N)) + 2):
    m = int(N // i)
    NM.append(N - m - prev)
    prev = N - m

cnt = N
nums = []
while cnt >= 1:
    nums.append(cnt)
    i = int(N // cnt)
    p = NM[i] if i < len(NM) else 1
    cnt -= p
nums.reverse()

# dp[k][n]: rec(n, k)
dp = defaultdict(lambda: defaultdict(int))
for n in nums:
    dp[1][n] = n
for k in range(2, K + 1):
    for n in nums:
        i = int(N // n)
        p = NM[i] if i < len(NM) else 1
        ret = dp[k - 1][i] * p % MOD
        cum = dp[k][n - p]
        dp[k][n] = (cum + ret) % MOD

ans = dp[K][N]
print((ans % MOD))

# ans = rec(N, K)
# print(ans % MOD)


# Optimized solution
import os
import sys
from collections import defaultdict

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

MOD = 10 ** 9 + 7
N, K = list(map(int, sys.stdin.readline().split()))

# ある程度数をまとめられるのでまとめておく
nexts = []
n = N
while True:
    p = int(N // (int(N // n) + 1))
    nexts.append(n)
    if p <= 0:
        break
    n = p

# dp[k][i]: i に続く k 文字のパターン数
dp = defaultdict(lambda: defaultdict(int))
prev = 0
for n, m in zip(nexts, reversed(nexts)):
    dp[0][m] = m
for k in range(1, K):
    dp[k][0] = 0
    prev = 0
    for n, m in zip(nexts, reversed(nexts)):
        dp[k][m] = (dp[k][prev] + dp[k-1][n] * (m-prev)) % MOD
        prev = m
print((dp[K - 1][N]))
# Original solution
N,K = list(map(int, input().split()))

L = [N]
c = 2
while c < N**0.5:
    if L[-1] != N//c:
        L.append(N//c)
    c += 1
if c > N**0.5:
    c -= 1
    L.append(c)
else:
    L.append(c)


L.reverse()
dp = [[0 for j in range(c+len(L))] for i in range(K+1)]

for j in range(1, c+1):
    dp[2][j] = N//j
for j in range(1, len(L)):
    dp[2][j+c] = N//L[j]*(L[j]-L[j-1])

for i in range(2, K):
    dp[i+1][-1] = dp[i][1]
    for j in range(2, c+len(L)):
        dp[i+1][c+len(L)-j] = dp[i+1][c+len(L)-j+1]+dp[i][j]
    for j in range(1, len(L)):
        dp[i+1][j+c] *= (L[j]-L[j-1])

        
print((sum(dp[K])%(10**9+7)))

# Optimized solution
N,K = list(map(int, input().split()))

L = [N]
c = 2
while c < N**0.5:
    if L[-1] != N//c:
        L.append(N//c)
    c += 1
if c > N**0.5:
    c -= 1
    L.append(c)
else:
    L.append(c)


L.reverse()
dp1 = [0 for _ in range(c+len(L))]
dp2 = [0 for _ in range(c+len(L))]

for j in range(1, c+1):
    dp1[j] = N//j
for j in range(1, len(L)):
    dp1[j+c] = N//L[j]*(L[j]-L[j-1])

for i in range(2, K):
    if i%2 == 0:
        dp2[-1] = dp1[1]
        for j in range(2, c+len(L)):
            dp2[c+len(L)-j] = dp2[c+len(L)-j+1]+dp1[j]
        for j in range(1, len(L)):
            dp2[j+c] *= (L[j]-L[j-1])
    else:
        dp1[-1] = dp2[1]
        for j in range(2, c+len(L)):
            dp1[c+len(L)-j] = dp1[c+len(L)-j+1]+dp2[j]
        for j in range(1, len(L)):
            dp1[j+c] *= (L[j]-L[j-1])

if K%2 == 0:
    ans = sum(dp1)
else:
    ans = sum(dp2)

print((ans%(10**9+7)))
# Original solution
N,K = list(map(int, input().split()))

L = [N]

for i in range(2, int(N**0.5)+1):
    if L[-1] != N//i:
        L.append(N//i)
        
c = int(N**0.5)+1
if c > N**0.5:
    c -= 1
    L.append(c)
else:
    L.append(c)


L.reverse()
dp1 = [0 for _ in range(c+len(L))]
dp2 = [0 for _ in range(c+len(L))]

for j in range(1, c+1):
    dp1[j] = N//j
for j in range(1, len(L)):
    dp1[j+c] = N//L[j]*(L[j]-L[j-1])

for i in range(2, K):
    if i%2 == 0:
        dp2[-1] = dp1[1]
        for j in range(2, c+len(L)):
            dp2[c+len(L)-j] = dp2[c+len(L)-j+1]+dp1[j]
        for j in range(1, len(L)):
            dp2[j+c] *= (L[j]-L[j-1])
    else:
        dp1[-1] = dp2[1]
        for j in range(2, c+len(L)):
            dp1[c+len(L)-j] = dp1[c+len(L)-j+1]+dp2[j]
        for j in range(1, len(L)):
            dp1[j+c] *= (L[j]-L[j-1])

if K%2 == 0:
    ans = sum(dp1)
else:
    ans = sum(dp2)

print((ans%(10**9+7)))

# Optimized solution
from itertools import accumulate

N,K = list(map(int, input().split()))
mod = 10**9+7
sqt = int(N**0.5)
cnt = [N // i-N // (i+1) for i in range(1, N//sqt)] + [1]*sqt
x = cnt
for _ in range(K):
    x = [(i*j)%mod for i, j in zip(accumulate(reversed(x)), cnt)]
    

print((x[-1]))
# Original solution
from itertools import accumulate
N,K=list(map(int,input().split()))
N_s=int(N**0.5)
list_a=[1]*N_s
list_b=[N//j-N_s for j in range(1,N_s+1)]
list_p=[N//j-N_s for j in range(1,N_s+1)]
for p in range(1,len(list_p)):
        list_p[p-1]=list_p[p-1]-list_p[p]
        
for p in range(1,len(list_b)):
    list_b[p-1]=list_b[p-1]-list_b[p]

list_bb=list(reversed(list(accumulate(reversed(list_b)))))
list_aa=list(accumulate(list_a))

mod=10**9+7

for i in range(K-1):
    temp=sum(list_a)
    list_an=[(temp+list_bb[j])%mod for j in range(N_s)]
    list_bn=[(list_p[j-1]*list_aa[j-1])%mod for j in range(1,N_s+1)]

    list_bbn=list(reversed(list(accumulate(reversed(list_bn)))))
    list_aa=list(accumulate(list_an))
    list_a=list_an
    list_b=list_bn
    list_bb=list_bbn
    
print(((sum(list_a)+sum(list_b))%mod))

# Optimized solution
from itertools import accumulate as ac
N,K=list(map(int,input().split()))
n=int(N**0.5)
mod=10**9+7
list_a=[1]*n
list_b=[N//j-N//(j+1) for j in range(1,n)]+[(N//n-n)]
list_p=[p for p in list_b]
list_aa=list(ac(list_a))
list_bb=list(reversed(list(ac(reversed(list_b)))))

for i in range(K-1):
    temp=sum(list_a)
    list_a=[(temp+list_bb[j])%mod for j in range(n)]
    list_b=[(list_p[j]*list_aa[j])%mod for j in range(n)]
    list_aa=list(ac(list_a))
    list_bb=list(reversed(list(ac(reversed(list_b)))))
    
print(((sum(list_a+list_b))%mod))
# Original solution
N,K = list(map(int, input().split()))
# As = [N//i for i in range(1,int(N**0.5)+1)]
# Bs = [As[i]-As[i+1] for i in range(len(As)-1)]
# Bs[0] -= 1
# Bs = sorted(Bs) + [1]
As = [] 
for i in range(1,int(N**0.5)+1):
    As.append(i)
    if N//i != i:
        As.append(N//i)
As = sorted(As,reverse=False)
nums = []
for i in range(len(As)-1):
    nums.append(As[i+1]-As[i])
nums = [1] + nums
nums.reverse()
mod = 10**9 + 7
ans = 0
dp = [[0] * len(As) for i in range(K+1)]


from itertools import accumulate
# print(As,nums)
dp[0][0] = 1
for i in range(K):
    # 1だと全通り分が成り立つし、Nだと1通り。
    # それぞれ種別にまとまっているので、それらをかける
    acc = list(accumulate(dp[i]))
    for j in range(len(As)):
        dp[i+1][len(As)-j-1] = acc[j]*nums[j]%mod
print((sum(dp[K])%mod))


# Optimized solution
from itertools import accumulate

N,K = list(map(int, input().split()))
As = [] 
for i in range(1,int(N**0.5)+1):
    As.append(i)
    if N//i != i:
        As.append(N//i)
As = sorted(As,reverse=False)
nums = []
for i in range(len(As)-1):
    nums.append(As[i+1]-As[i])
nums = [1] + nums
nums.reverse()
mod = 10**9 + 7
ans = 0
dp = [[0] * len(As) for i in range(K+1)]


dp[0][0] = 1
for i in range(K):
    # 1だと全通り分が成り立つし、Nだと1通り。
    # それぞれ種別にまとまっているので、それらをかける
    acc = list(accumulate(dp[i]))
    for j in range(len(As)):
        dp[i+1][len(As)-j-1] = acc[j]*nums[j]%mod
print((sum(dp[K])%mod))
# Original solution
import sys
input = sys.stdin.readline
from itertools import accumulate
MOD = 10**9+7
  
n, k = list(map(int, input().split()))
S = set()
i = 1
while i * i <= n:
  S.add(i)
  S.add(n//i)
  i += 1
L = [0] + sorted(S)
l = len(L) - 1
num = [0]*l
for i in range(l):
  num[i] = L[i+1] - L[i]
dp = [0]*l
dp[0] = 1
for _ in range(k):
  A = list(accumulate(dp))
  for i in range(l):
    dp[i] = A[l-1-i] * num[i]
    dp[i] %= MOD
ans = sum(dp) % MOD
print(ans)

# Optimized solution
import sys
input = sys.stdin.readline
from itertools import accumulate
MOD = 10**9+7

def main():
  n, k = list(map(int, input().split()))
  S = set()
  i = 1
  while i * i <= n:
    S.add(i)
    S.add(n//i)
    i += 1
  L = [0] + sorted(S)
  l = len(L) - 1
  num = [0]*l
  for i in range(l):
    num[i] = L[i+1] - L[i]
  dp = [0]*l
  dp[0] = 1
  for _ in range(k):
    A = list(accumulate(dp))
    for i in range(l):
      dp[i] = A[l-1-i] * num[i]
      dp[i] %= MOD
  ans = sum(dp) % MOD
  print(ans)

if __name__ == "__main__":
  main()
# Original solution
import math
import copy
N, K = list(map(int, (input().split())))

mod = 10**9 + 7

ans_array = []
divide_max = N

for i in range(2, math.floor(math.sqrt(N)) + 2):
    divide = math.floor(N / i)
    ans_array.append(divide_max - divide)
    divide_max = divide

for i in range(divide):
    ans_array.append(1)
ans_array = ans_array[::-1]
ans_count = copy.deepcopy(ans_array)
# print(ans_count)
ans_length = len(ans_array)
ans_acc = [0] * ans_length

for k in range(2, K + 1):
    ans_acc[0] = ans_array[0]
    for i in range(1, ans_length):
        ans_acc[i] = (ans_acc[i - 1] + ans_array[i]) % mod
    # print(ans_array)
    # print(ans_acc)
    for i in range(ans_length):
        ans_array[i] = ans_acc[ans_length-i-1] * ans_count[i] % mod

ans_acc[0] = ans_array[0]
for i in range(1, ans_length):
    ans_acc[i] = (ans_acc[i - 1] + ans_array[i]) % mod

print((ans_acc[-1]))

# Optimized solution
import math
N, K = list(map(int, (input().split())))

mod = 10**9 + 7

ans_array = []
divide_max = N
divide_count = []

for i in range(2, math.floor(math.sqrt(N)) + 2):
    divide = math.floor(N / i)
    ans_array.append(divide_max - divide)
    divide_count.append(divide_max - divide)
    divide_max = divide

for i in range(divide):
    ans_array.append(1)
ans_array = ans_array[::-1]
# print(ans_count)
ans_length = len(ans_array)
ans_acc = [0] * ans_length

for k in range(2, K + 1):
    ans_acc[0] = ans_array[0]
    for i in range(1, ans_length):
        ans_acc[i] = (ans_acc[i - 1] + ans_array[i]) % mod
    # print(ans_array)
    # print(ans_acc)
    for i in range(divide):
        ans_array[i] = ans_acc[ans_length - i - 1]
    for i in range(divide, ans_length):
        ans_array[i] = ans_acc[ans_length - i - 1] * divide_count[
            ans_length - 1 - i] % mod

ans_acc[0] = ans_array[0]
for i in range(1, ans_length):
    ans_acc[i] = (ans_acc[i - 1] + ans_array[i]) % mod

print((ans_acc[-1]))
# Original solution
n, k = [int(x) for x in input().strip().split(" ")]
mod = pow(10, 9) + 7

ll = []
ks = []
cc = 0
last = 0
for i in range(n):
    i += 1
    if n//i < i:
        last = n//i
        break
    ll.append(n//i)
    ks.append(1)
    last = n//i
    cc += 1

while True:
    if last == 0:
        break
    if last >= len(ll):
        mm = last
    else:
        mm = ll[last]
    ll.append(last * (ll[last-1] - mm))
    ks.append((ll[last-1] - mm))
    last -= 1
n_l = len(ll)

for _ in range(k-2):
    nll = []
    m = sum(ll) % mod
    for i in range(n_l):
        x = n_l - i - 1
        nll.append((m * ks[i]) % mod)
        m -= (mod + ll[x]) % mod
    ll = nll[:]
print((sum(ll) % mod))


# Optimized solution
from itertools import accumulate as r;n,k=list(map(int,input().split()));m=10**9+7;j=int(n**0.5);c=[n//(i+1)-n//(i+2) for i in range(n//(j+1))]+[1]*j;x=c;exec("x=[(y*d)%m for y,d in zip(r(x[::-1]),c)];"*k);print((x[-1]))