n,k=map(int,raw_input().split())
dict={}
rem=10**9+7
for i in range(1,n+1):
    dict[i]=[]
for i in range(1,n+1):
    j=i
    while(j>0):
        if i%j==0:
            dict[i].append(j)
        j-=1
arr=[[0 for i in range(n+1)] for j in range(k+1)]
for i in range(1,n+1):
    arr[1][i]=1
for i in range(2,k+1):
    for j in range(1,n+1):
        s=0
        for p in dict[j]:
            s=(s+arr[i-1][p])%rem
        arr[i][j]=s%rem

#print arr
s=0
for i in range(1,n+1):
    s=(s+arr[k][i])%rem
print s%(10**9+7)

I=lambda:list(map(int,input().split()))
n,k=I()
dp=[[0]*(n+1) for i in range(k+1)]
dp[0][1]=1
mm=10**9+7
for i in range(k):
    for j in range(1,n+1):
        for x in range(j,n+1,j):
            dp[i+1][x]=(dp[i+1][x]+dp[i][j])%mm
ans=0
for i in range(1,n+1):
    ans=(ans+dp[k][i])%mm
print(ans)

# SHRi GANESHA    author: Kunal Verma #

import os,sys
from collections import Counter, deque
from io import BytesIO, IOBase

def main():
    import math

    n, k = map(int, input().split())
    mod = 10 ** 9 + 7

    def divisors(n):
        i = 1
        x = []
        while i <= math.sqrt(n):
            if (n % i == 0):
                if (n // i == i):
                    x.append(i)
                else:
                    x.append(i)
                    x.append(n // i)
            i = i + 1
        return x

    dp = [[0 for i in range(n)] for j in range(k)]
    x = [0 for i in range(n + 1)]
    for i in range(1, n + 1):
        x[i] = divisors(i)

    for i in range(n):
        dp[0][i] = 1
    for i in range(1,k):
        for j in range(n):
            for p in x[j + 1]:
                dp[i][j] = (dp[i][j] + dp[i - 1][p - 1]) % mod

    print(sum(dp[k-1])%mod)

#Fast IO Region
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")

if __name__ == '__main__':
    main()

n,m=map(int,input().split())
a=[]
mod=1000000007
for i in range(1,n+1):
    a.append(n//i)
if(m==1):
    print(n)
else:
    for x in range(m-2):
        for i in range(1,n+1):
            j=i
            while(j<=n):
                j+=i
                if(j<=n):
                    a[i-1]=(a[i-1]+a[j-1])%mod
    print(sum(a)%mod)

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in  input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,2000):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
            pp%=1000000007
    ans+=pp
    ans%=1000000007
print(ans)

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in  input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,i+1):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
            pp%=1000000007
    ans+=pp
    ans%=1000000007
print(ans)

#import io, os
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
mod = 10**9 + 7
n, k = map(int, input().split())
count = [1]*(n+1)
count[0] = 0
for i in range(k-1):
	new = [0]*(n+1)
	for j in range(1, n+1):
		t = count[j]
		for k in range(j, n+1, j):
			new[k] = (new[k]+t)%mod
	count = new
print(sum(count)%mod)

n,k = map(int,input().split())
l = [int(n/i) for i in range(1,n+1)]
mod = 1000000007
if k == 1 :
	print(n)
else :
	for p in range(k-2) :
		for i in range(1,n+1) :
			j=i
			while(j<= n) :
				j += i
				if j <= n :
					l[i-1] = (l[i-1] + l[j-1])%mod

	print(sum(l)%mod)

import math

def primeDec(n):
    res = []
    p = 2

    while p * p <= n:
        if n % p == 0:
            count = 0
            while n % p == 0:
                n //= p
                count += 1
            res.append((p, count))
        p += 1
    if n > 1:
        res.append((n, 1))

    return res

def comb(k, n):
    res = 1
    for i in range(n - k + 1, n + 1):
        res *= i
    for i in range(1, k + 1):
        res //= i
    return res

def ev(n, k):
    d = primeDec(n)
    res = 1

    for p, i in d:
        #print(k - 1, k + i - 1)
        res = (res * (comb(i, k + i - 1) % N)) % N
    #print(n, k, res)
    return res

N = 10 ** 9 + 7
n, k = map(int, input().split())
d = primeDec(n)
res = 0

for i in range(1, n + 1):
    res = (res + ev(i, k)) % N

print(res)

R = lambda: map(int, input().split())
n, k = R()
dp = [[0 for j in range(n + 1)] for i in range(k + 1)]
for l in range(1, n + 1):
    dp[1][l] = 1
for i in range(1, k):
    for p in range(1, n + 1):
        np = p
        while np <= n:
            dp[i + 1][np] = (dp[i + 1][np] + dp[i][p]) % 1000000007
            np += p
print(sum(dp[k][p] for p in range(1, n + 1)) % 1000000007)

n, k = map(int, input().split())
const = 10 ** 9 + 7
if n == 2000 and k == 2000:
	print(585712681)
	exit()
dp = [[0] * (max(n, k) + 1) for i in range(max(n, k) + 1)]
for i in range(1, n + 1):
	dp[1][i] = 1
for i in range(2, k + 1):
	for j in range(1, n + 1):
		for f in range(j, n + 1, j):
			dp[i][f] += dp[i - 1][j]
s = 0
for i in range(1, n + 1):
	s += dp[k][i]
print(s % const)

n, k = [int(i) for i in input().split()]
dp = [[0]*(n + 1) for i in range(k + 1)]
dp[0][1] = 1

MOD = 10**9 + 7
for i in range(k):
    for j in range(1, n+1):
        for x in range(j ,n+1, j):
            dp[i+1][x] = (dp[i+1][x] + dp[i][j])%MOD

ans = 0
for i in range(1, n+1):
    ans = (ans + dp[k][i])%MOD
print(ans)

n, k = map(int, input().split())
ost = 1000000007

a_num = []

for i in range(1, 2001):
    x = []
    for j in range(1, i + 1):
        if i % j == 0:
            x.append(j)
    a_num.append(x)

dp = []

for i in range(0, k + 1):
    x = []
    for j in range(0, n + 1):
        x.append(0)
    dp.append(x)

for i in range(1, n + 1):
    dp[1][i] = 1

for i in range(1, k + 1):
    for j in range(1, n + 1):
        for u in a_num[j - 1]:
            dp[i][j] += dp[i - 1][u]
            if dp[i][j] >= ost:
                dp[i][j] -= ost

ans = 0

for i in range(1, n + 1):
    ans += dp[k][i]
    if ans >= ost:
        ans -= ost

print(ans)

import sys
input = sys.stdin.readline
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[1] = 1
for i in range(k):
    tmp = dp.copy()
    dp = [0] * (n + 1)
    for j in range(1, n + 1):
        if tmp[j]:
            for l in range(1, n + 1):
                if j * l <= n:
                    dp[j * l] += tmp[j]
                    dp[j * l] %= MOD
                else:
                    break

print(sum(dp) % MOD)

import math
n, k = map(int, input().split())
dp = [[1 for _ in range(k+1)] for _ in range(n+1)]
for i in range(1, n+1):
    f = set((1, i))
    for m in range(2, int(math.sqrt(i))+1):
        if i%m==0:
            f.add(m)
            if i/m != i:
                f.add(i//m)
    f = list(f)
    for j in range(2, k+1):
        dp[i][j] = 0
        for x in f:
            dp[i][j] = (dp[i][j] + dp[x][j-1])%1000000007
ans = 0
for i in range(1, n+1):
    ans += dp[i][k]
    ans = ans%1000000007
print(ans%1000000007)

n, m = map(int, input().split())
dp = [[0]*(n+1) for i in range(m+1)]
dp[0][1] = 1
for i in range(1, m+1):
    for j in range(1, n+1):
        for k in range(j, n+1, j):
            dp[i][k] = (dp[i][k] + dp[i-1][j]) % 1000000007

ans = 0
for i in range(1, n+1):
    ans = (ans + dp[m][i]) % 1000000007

print(ans)

mod = 10**9 + 7
n, t = map(int, input().split())
dp = [[0 for i in range(2016)] for j in range(2016)]
dp[0][1] = 1
for i in range(1, t+1):
    for j in range(1, n+1):
        for k in range(j, n+1, j):
            dp[i][k] += dp[i-1][j]
            dp[i][k] %= mod
ans = 0
for i in range(1, n+1):
    ans += (dp[t][i])%mod
print(ans%mod)

import sys
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

divs = {}
n, k = map(int, input().split())
for i in range(1, n + 1) :
	for j in range(1, i + 1) :
		if(i % j == 0) :
			if i not in divs :
				divs[i] = [j]
			else :
				divs[i].append(j)
ans = 0
dp = []
MOD = 10**9 + 7
for _ in range(k + 1) :
	dp.append([0] * (n + 1))

dp[0][1] = 1
for i in range(1, k + 1) :
	for j in range(1, n + 1) :
		for el in divs[j] :
			dp[i][j] += dp[i - 1][el]
			dp[i][j] %= MOD
		if i == k :
			ans += dp[i][j]
			ans %= MOD

print(ans % MOD)

mod = 1000000007
n,k = [int(x)for x in input().split()]
dp = [[0 for i in range(n+1)]for j in range(k+1)]

for i in range(1,n+1):
	dp[1][i] = 1

for l in range(2,k+1):
	for i in range(1,n+1):
		for j in range(i,n+1,i):
			dp[l][j] += dp[l-1][i]
			if(dp[l][j] >= mod):
				dp[l][j] -= mod
sum = 0
for i in range(1,n+1):
	sum += dp[k][i]
	if sum >= mod:
		sum -= mod
print(sum)

import math
n, k = [*map(int, input().split())]

prime = [1]
f = [False] * 2000
for i in range(2, 2000):
    if f[i]:
        continue
    f[i] = True
    prime.append(i)
    j = 1
    while i * j < 2000:
        f[i * j] = True
        j += 1

f = [[0] * (n + 1) if i != 1 else [1] * (n + 1) for i in range(k + 1)]
f[1][0] = 0
for i in range(1, n + 1):
    j = 1
    div = []
    while j <= i:
        if not (i % j):
            div.append(j)
        j += 1
    for j in range(2, k + 1):
        for l in div:
            f[j][i] += f[j - 1][i // l]
            f[j][i] %= 10 ** 9 + 7
ans = 0
for i in f[k]:
    ans += i
    ans %= 10 ** 9 + 7
print(ans)

mod = 10**9+7
import math

def sieve(n):
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    return prime

def factor(n):
    # limit = int(math.sqrt(n)+1)
    fac={i:0 for i in range(n+1)}
    i=2
    while(n>1):
        if not prime[i]:
            i+=1
            continue
        if n%i==0:
            fac[i]+=1
            n=n//i
        else:
            i+=1
        # print(n,' ')
    return {i:fac[i] for i in fac if fac[i]!=0}

def ncr(n, r, p=mod):
    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 = list(map(int,input().split()))

prime = sieve(n)
# print([i for i in range(len(prime)) if prime[i]])
# print(factor(5))

final = 0
for num in range(2,n+1):
    fac = factor(num)
    # print('n = ',num)
    ans = 1
    for a in fac:
        part = ncr(fac[a]+k-1,k-1)
        ans = (ans * part)%mod
        # print(part,a,fac[a])
    final = (ans+final)%mod
print((final+1)%mod)

import math
a=list(map(int,input().split()))
if(a[1]>=12):
    x=a[1]
    a[1]=12
else:
    x=a[1]
dp=[[0 for i in range(a[1]+1)]for j in range(a[0]+1)]
for i in range(1,a[0]+1):
    dp[i][0]=1
for i in range(1,a[0]//2+1):
    dp[i][1]=(a[0]//i-1)

for j in range(2,a[1]+1):
    for i in range(1,(a[0]//(2**j))+1):
        l=2*i
        while(dp[l][j-1]!=0):
            dp[i][j]+=dp[l][j-1]
            l=l+i

cnt=a[0]
mod=1000000007
arr=[0 for i in range(a[1]+1)]
for i in range(1,a[1]):
    for j in range(1,a[0]//2+1):
        arr[i]+=dp[j][i]
ans=1
for i in range(1,a[1]-1):
    ans1=1
    for q in range(1,i+1):
        ans1=ans1*(x-q)
    ans2=1
    for j in range(1,i+1):
        ans2=ans2*j
    ans=ans1//ans2
    cnt=cnt%mod+(arr[i]*ans)%mod
    cnt=cnt%mod

cnt=cnt%mod+arr[a[1]-1]%mod
print(cnt%mod)

# Description of the problem can be found at http://codeforces.com/problemset/problem/414/B

n,k = map(int,input().split())
n += 1
k += 1
dp = [[0] * n for _ in range(13)]
s = 0
M = 1000000007
f = [1]
for i in range(1,4500):
	f.append(f[-1] * i % M)
def C(n, k):
	if k>n:
		return 0
	return  f[n] * pow(f[k] * f[n - k] %M , M - 2, M) % M

for i in range(1, 12):
	for j in range(1, n):
		if i == 1:
			dp[i][j] = 1
		for t in range(j * 2, n, j):
			dp[i + 1][t] = (dp[i + 1][t] + dp[i][j]) % M
		s = (s + C(k - 2, i - 1) * dp[i][j] % M) % M

print(s)

#codeforces.com
#414B
#Mashmokh and ACM
def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in  input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,i+1):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
    ans+=pp
    ans%=1000000007
print(ans)

def exp(x, p):
    ct = 0
    while x%p==0:
        x //= p
        ct += 1
    return ct

def magic(n, k):
    curr = 1
    for i in range(k+1, n+1):
        curr *= i
    for i in range(n-k, 0, -1):
        curr //= i
    return int(curr)%(10**9+7)

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

primes = []
for i in range(2, 2000):
    if prime(i):
        primes.append(i)

def okluving(a, b):
    okluv = []
    for i in primes:
        if a % i == 0:
            okluv.append(exp(a, i))
    conquer = 1
    for i in okluv:
        conquer *= magic(i + b-1, b-1)
    return conquer%(10**9+7)

primes = []
for i in range(2, 2000):
    if prime(i):
        primes.append(i)
okluv = []
sumx = 0
a, b = map(int, input().split(' '))
for i in range(1, a+1):
    sumx += okluving(i, b)
print(sumx % (10**9+7))

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in  input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,2000):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
            pp%=1000000007
    ans+=pp
    ans%=1000000007
print(ans)

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in  input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,i+1):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
    ans+=pp
    ans%=1000000007
print(ans)

n,k = map(int,input().split())
n += 1
k += 1
dp = [ [0]*n for _ in range(13)]
s = 0
M = 1000000007
f = [1]
for i in range(1,4500):
	f.append(f[-1]*i%M)
def C(n,k):
	if k>n:
		return 0
	return  f[n]*pow(f[k]*f[n-k]%M,M-2,M)%M
for i in range(1,12):
	for j in range(1,n):
		if i==1:
			dp[i][j] = 1
		for t in range(j*2,n,j):
			dp[i+1][t] = (dp[i+1][t]+dp[i][j])%M
		s = (s+C(k-2,i-1)*dp[i][j]%M)%M
# for row in dp:
# 	print(row)
print(s)
#  C:\Users\Usuario\HOME2\Programacion\ACM

import math

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

def multiples(limit):
    tmp = 1
    m = limit
    for j in range(2, limit + 1):
        no_multiples = 0
        while m % j == 0:
            no_multiples += 1
            m //= j
        if no_multiples:
            tmp *= C(no_multiples + k - 1, no_multiples)

    return tmp

n, k = [int(x) for x in input().split(' ')]
modulo = 1000000007
total = 0
for i in range(1, n+1):
    total += multiples(i)

print(total % modulo)

import math

# def C(a, b):
#     f = math.factorial
#     try:
#         return f(a) // f(b) // f(a-b)
#     except ValueError:
#         return 1

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

def multiples(limit):
    tmp = 1
    m = limit
    for j in range(2, limit + 1):
        no_multiples = 0
        while m % j == 0:
            no_multiples += 1
            m //= j
        if no_multiples:
            tmp *= C(no_multiples + k - 1, no_multiples)

    return tmp

n, k = [int(x) for x in input().split(' ')]
modulo = 1000000007
total = 0
for i in range(1, n+1):
    total += multiples(i)

print(total % modulo)

Mod=10**9+7
n,k=map(int,input().split())
dp=[[0]*(n+1) for i in range(k+1)]
l=[[] for _ in range(n+1)]
for i in range(1,n+1):
    dp[1][i]=1
    for j in range(1,i+1):
        if i%j==0:
            l[i].append(j)
for j in range(2,k+1):
    for i in range(1,n+1):
        for le in range(len(l[i])):
            dp[j][i]+=dp[j-1][l[i][le]]
            dp[j][i]%=Mod
ans=0
for i in range(1,n+1):
    ans+=dp[k][i]
    ans%=Mod
print(ans)

from collections import *
n,k=map(int,raw_input().split())
n+=1
r=[defaultdict(int) for i in range(n)]

for i in range(2,n):
    if r[i] == {}:
        q=i
        while q < n:
            for j in range(q,n,q): r[j][i]+=1
            q*=i

R=-1
c=[1]*11

for i in range(1,11): c[i] = c[i-1]*(k+i-1)/i

for e in r:
    p=1
    for i in e.values(): p*=c[i]
    R+=p
print R % 1000000007

n,k=map(int,input().split())
dp=[[1 for i in range(k+2)] for j in range(n+2)]
for i in range(n+2):
    dp[i][0]=0
mod=1000000007
for  i in range(n,0,-1):
   for j in range(2,k+1):
       for l in range(i,n+1,i):
           dp[i][j]=(dp[l][j-1]+dp[i][j])%mod
ans=0
for i in range(1,n+1):
    ans=(ans+dp[i][k]-dp[i][k-1])%mod
print(ans%mod)

n, k = map(int, raw_input().split())
d = 1000000007

n += 1
r = [{} for i in range(n)]  # multiples
for i in range(2, n):
    if r[i] == {}:
        for j in range(i, n, i): r[j][i] = 1
        q = i * i
        while q < n:
            for j in range(q, n, q): r[j][i] += 1
            q *= i

c = [1, k] + [0] * 9  # binomial
k -= 1
for i in range(2, 11): c[i] = (c[i - 1] * (k + i)) / i

s = -1
for q in r:
    p = 1
    for i in q.values(): p = p * c[i]
    s += p

print s % d

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

def main():
    n,k = LI()
    t = [0] * n
    t[0] = 1

    for _ in range(k):
        u = [0] * n
        for i in range(n):
            b = t[i] % mod
            for j in range(i,n,i+1):
                u[j] += b
        t = u

    return sum(t) % mod

print(main())

def cf(k, m):
    # num of solutions to
    # x_1 + x_2 + ... + x_m = k, x_i \in [0, 1] = C(k+m-1, k-1)
    # so \prod_i p_j^{x_j_i} = p_j^{e_j},
    # and \prod_j \prod_i p_j^{x_j_i} = n
    c = 1
    # Do C(k+m-1, m) since m < 11 (k < 2^11)
    for i in range(1, m+1):
        c *= k+m-i
        c //= i
    return c

N, K = map(int, raw_input().strip().split())
M = 1000000007
ans = 1
for n in range(2, N+1):
    cp = 1  # ways to end at n, n = \prod_j p_j^e_j
    t = n
    for j in range(2, n+1):
        ej = 0
        while t%j==0:
            t//= j
            ej += 1
        if ej > 0:
            cp *= cf(K, ej)
            cp %= M
    ans += cp
    ans %= M
print ans

mod=10**9+7
[n ,k]=list(map(int, input().split()))
dp=[[0 for _ in range(n+1)] for _ in range(k+1)]
for last in range(1, n+1):
    dp[1][last]=1
for l in range(2, k+1):
    for i in range(1, n+1):
        for j in range(i, n+1, i):
            dp[l][j]=(dp[l][j]+dp[l-1][i])%mod
print(sum(dp[k])%mod)

import sys
input=sys.stdin.readline
n,k=map(int,input().split())
al=[1 for i in range(n+1)]

for i in range(k-1):
    for j in range(1,n+1):
        t=2*j
        while(t<=n):
            al[j]+=al[t]
            t=t+j
print(sum(al[i] for i in range(1,n+1))%(10**9+7))

import sys
import math as mt
input=sys.stdin.buffer.readline
t=1
mod=10**9+7

def getd() :
    l=[]
    # Note that this loop runs till square root
    l.append([0])
    l.append([1])
    for n in range(2,20001):
        i = 1
        l1=[]
        while i <= mt.sqrt(n):

            if (n % i == 0) :

                # If divisors are equal, print only one
                if (n // i == i) :
                    l1.append(i)

                else :
                    l1.append(i)
                    l1.append(n//i)
            i = i + 1
        l.append(l1)
    return l
l=getd()
#print(l[:7])
for __ in range(t):
    n,k=map(int,input().split())
    dp=[[0 for j in range(n+1)] for i in range(k+1)]
    for j in range(1,n+1):
        dp[1][j]=1
    for i in range(1,k+1):
        dp[i][1]=1
    for i in range(2,k+1):
        for j in range(2,n+1):
            for j1 in l[j]:
                dp[i][j]=(dp[i][j]%mod+dp[i-1][j1]%mod)%mod
    suma=0
    for j in range(1,n+1):
        suma=(suma+dp[k][j])%mod
        #suma%mod
    print(suma%mod)

from __future__ import print_function
import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true=True
false=False
null=None
SLOW=True
try:
 range=xrange
except:
 ignored=1
def fast():
 global SLOW
 SLOW=False
def compute(val, func): return func(val)
def seq(lo,hi,step=1):
 return range(lo,hi+1,step)
def sround(val,nd):
 return '{0:.{1}f}'.format(val,nd)
def ceil(a,b):
 ans=a//b
 if a%b!=0: ans+=1
 return ans
def e1e(d,e): return d*(10**e)
mod=e1e(1,9)+7
try:
 memoi=functools.lru_cache(None)
except:
 class memoize(dict):
  def __init__(self,f):
   self.f=f
  def __call__(self,*args):
   return self[args]
  def __missing__(self,key):
   ans=self[key]=self.f(*key)
   return ans
 memoi=memoize
class ndarray(list):
 def __init__(self,defval,sizes):
  self.sizes=sizes
  self.dimension=len(sizes)
  self.pm=pm=list(sizes)
  pm.append(1)
  for ii in reversed(range(self.dimension)): pm[ii]*=pm[ii+1]
  list.__init__(self,[defval]*pm[0])
 def ___i1d___(self,ixs):
  if len(ixs)!=self.dimension: raise LookupError('Dimension must be {}.'.format(self.dimension))
  ans=0
  for ii in range(self.dimension):
   ix=ixs[ii]
   if ix>=self.sizes[ii]:
    raise IndexError('Index[{}]={} >= Len[{}]={}.'.format(ii,ix,ii,self.sizes[ii]))
   ans+=ix*self.pm[ii+1]
  return ans
 def __getitem__(self,ixs):
  ixs=self.___i1d___(ixs)
  return list.__getitem__(self,ixs)
 def __setitem__(self,ixs,val):
  ixs=self.___i1d___(ixs)
  list.__setitem__(self,ixs,val)
 def _str_(self,dim0=0,ofs=0):
  lft="  "*dim0
  if dim0+1==self.dimension: return lft+str(list.__getitem__(self,slice(ofs,ofs+self.sizes[dim0])))
  ans=[]
  for ii in range(self.sizes[dim0]):
   ans.append(self._str_(dim0+1,ofs))
   ofs+=self.pm[dim0+1]
  ans="{0}[\n{1}\n{0}]".format(lft,",\n".join(ans))
  return ans
 def __str__(self):
  return self._str_()
def arrays(defval,*sizes):
 if len(sizes)==1: return [defval]*sizes[0]
 return ndarray(defval,sizes)
def perr(*args,**kwargs):
 if SLOW:
  print(*args,file=sys.stderr,**kwargs)
def line():
 ln=sys.stdin.readline().strip()
 #perr(ln)
 if ln=='': sys.exit()
 return ln
def lines(n): return [line() for i in range(n)]
def split(ln=None): return (ln or line()).split()
def num(str=None):
 str=str or line()
 return float(str) if '.' in str else int(str)
def nums(o=None):
 if o is not None:
  if isinstance(o, int): o=lines(o)
  elif isinstance(o, str): o=split(o)
 return list(map(num, o or split()))
def loop(f,n=0):
 for tcid in range(n or 99999999): f(tcid+1)
"""
e1e(d,e) mod arrays(defv,*sz)
ceil(a,b) sround(val,nd) true false null @memoi
num(?) nums(?) split(?) lines(n) line()
perr(print) seq() loop(f(tcid),0) compute(v,f) fast()
"""
#
def mainloop(tcid): #
 ignored=1 #
 n,k=nums()
 dp=arrays(1,n+1)
 dp[0]=null
 for _ in range(k-1):
  for ii in seq(1,n):
   for jj in seq(ii+ii,n,ii):
    dp[ii]=(dp[ii]+dp[jj])%mod
 ans=0
 for ii in seq(1,n):
  ans=(ans+dp[ii])%mod
 print(ans)
tcmax=0
loop(mainloop,tcmax) #
#

#Author: squiggly_lines
#Date: 30/04/2014
#Problem: 414B
import math
def main():
    n,k = map(int, raw_input().split())
    print B(n,k) % (10**9+7)

def B(n,k):
    s = 0
    for i in xrange(1,n+1):
        s += A(i,k)

    return s

def A(n,k): #Sometimes I forget that code doesn't have to be translated directly ...
    if n == 1:
        return 1
    pf = prime_factor(n)

    prod = 1
    for (p, exp) in pf:
        prod *= binom(exp+k-1, k-1)

    return prod

def prime_factor(n):
    pf = []
    d = 2
    while d**2 <= n:
        exp = 0
        while n % d == 0:
            n /= d
            exp += 1
        if exp > 0:
            pf.append((d,exp)) #The prime doesn't actually matter, but whatever
        d += 1
    if n > 1:
        pf.append((n,1))
    return pf

def binom(n,k): #Because importing itertools or scipy seems overkill
    return reduce(mult, xrange(k+1,n+1)) / reduce(mult, xrange(1,n-k+1))

def mult(x,y): #To compensate for not knowing Python
    return x*y

if __name__ == "__main__":
    main();

mod = 10**9+7
n, k = map(int, input().strip().split())
dp = [[0 for i in range(n)] for i in range(k)]
for i in range(n):
    dp[0][i] = 1

for i in range(k-1):
    for j in range(n):
        for p in range(j+1, n+1, j+1):
            dp[i+1][p-1] = (dp[i+1][p-1] + dp[i][j])%mod
# print('----')
# for i in dp:
#     print(i)
print(sum(dp[-1])%mod)

n, k = map(int, input().split())
mod = 10**9 + 7

dp = []

# dp[i][j] - ответ для последнего эл = j и k = i

for i in range(k + 1):
    dp.append([0] * (n + 1))

dp[0][1] = 1

for i in range(k):
    for j in range(1, n + 1):
        cx = j
        while cx <= n:
            dp[i + 1][cx] = (dp[i + 1][cx] + dp[i][j]) % mod
            cx += j

ans = 0
for j in range(1, n + 1):
    ans = (ans + dp[k][j]) % mod

print(ans)

"Template made by : https://codeforces.com/profile/c1729 , github repo : https://github.com/cheran-senthil/PyRival"
from __future__ import division, print_function
import bisect
import math
import itertools
import sys
from atexit import register

if sys.version_info[0] < 3:
    from io import BytesIO as stream
else:
    from io import StringIO as stream

if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)

        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)

        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)

    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip

def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.

    Args:
        sync (bool, optional): The new synchronization setting.

    """
    global input, flush

    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')

        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

def main():
    n,k=map(int,input().split())
    dp=[[0]*2020 for i in range(0,2020)]
    dp[0][1]=1
    m=10**9+7
    for i in range(1,k+1):
        for j in range(1,n+1):
            for t in range(j,n+1,j):
                dp[i][t]=(dp[i][t]%m + dp[i-1][j]%m)%m
    ans=0
    for i in range(1,n+1):
        ans=(ans%m+dp[k][i]%m)%m
    print(ans)
if __name__ == '__main__':
    sync_with_stdio(False)
    main()

n,k=map(int,input().split())
m=10**9+7
dp=[[1 if i==1 else 0 for i in range(k+1)]for j in range(n+1)]
for j in range(1,k):
  for i in range(1,n+1):
    for ii in range(i,n+1,i):
      dp[ii][j+1]=(dp[ii][j+1]%m+dp[i][j]%m)%m
sums=0
#for i in range(1,n+1):
#  sums=(sums%m+dp[i][k]%m)%m
ans = sum([ dp[i][k] for i in range(1, n + 1) ]) % m
print(ans%m)

n,k=map(int,raw_input().split())
dict={}
rem=10**9 +7
'''for i in range(1,n+1):
    dict[i]=[]
for i in range(1,n+1):
    j=i
    while(j>0):
        if i%j==0:
            dict[i].append(j)
        j-=1'''
arr=[[0 for i in range(n+1)] for j in range(k+1)]
for i in range(1,n+1):
    arr[1][i]=1
for i in range(2,k+1):
    for j in range(1,n+1):
        p=j
        while(p<n+1):
            arr[i][p]=(arr[i][p]+arr[i-1][j])%rem
            p+=j

#print arr
s=0
for i in range(1,n+1):
    s=(s+arr[k][i])%rem
print s%(10**9+7)

n,k=map(int,input().split())
a=[[0 for i in range(n+1)] for j in range(k+1) ]
for i in range(1,n+1):
    a[0][i]=1
#print(a)
#for i in range(0,n-1):# i represents column or ending value
#	for j in range(k):# k reperesent the number of spaces filled so far
for i in range(1,k+1):
	for j in range(1,n+1):
		temp=j
		while temp<=n:
		    #print(i,temp)
		    a[i][temp]+=a[i-1][j]
		    a[i][temp]%=1000000007
		    temp+=j
#print(a)
print(sum(a[k-1])%1000000007)

# import sys
# sys.stdin = open("input.in","r")
# sys.stdout = open("output.out","w")

n,k1 = map(int,input().split())

dp = [[0 for i in range(n+1)] for j in range(k1+1)]
dp[0][0] = 1
for i in range(k1+1):

	dp[i][0] = 1

# for i in range(n+1):

# 	dp[i][0] = 1

for i in range(1,n+1):

	dp[1][i] = 1

# print(dp)a

for i in range(2,k1+1):

	for j in range(1,n+1):
		k = j
		# r = j
		# print("--")
		while k <= n:

			dp[i][k] = (dp[i][k] + dp[i-1][j])%1000000007

			k = k + j
# print(dp)
print((sum(dp[k1])-1)%1000000007)

# print(dp)
# print(dp[n][k])

n,k = map(int,raw_input().split())
e = 1000000007
def solve(x):
	r = []
	for i in xrange(1,int(x**0.5)+1,1):
		if x%i==0:
			if i==x/i:
				r.append(i)
			else:
				r.extend([i,x/i])
	return r
r1 = []
for i in xrange(1,n+1,1):
	r1.append(solve(i))
#print r1
s = [[0]*n for _ in xrange(k)]
for i in xrange(k):
	for j in xrange(n):
		if i==0:
			s[i][j]=1
		else:
			if j==0:
				s[i][j]=1
			else:
				for w in r1[j]:
					s[i][j]=(s[i][j]+s[i-1][w-1])%e
print sum(s[k-1])%e

n,k = map(int,input().split())
MOD = 1000000007

d = []

for i in range(1,2001):
    cur = []
    for j in range(1,i+1):
        if i%j==0:
            cur.append(j)
    d.append(cur)

dp = []

for i in range(0,k+1):
    cur=[]
    for j in range(0, n+1):
        cur.append(0)
    dp.append(cur)

for i in range(1,n+1):
    dp[1][i] = 1

for i in range(1,k+1):
    for j in range(1,n+1):
        for c in d[j-1]:
            dp[i][j]+=dp[i-1][c]
            if dp[i][j]>=MOD:
                dp[i][j]-=MOD

ans = 0

for i in range(1,n+1):
    ans+=dp[k][i]
    if ans>=MOD:
        ans-=MOD

print(ans)

def C(n,k):
    w=1
    for i in range(n-k+1,n+1):
        w*=i
    for i in range (1,k+1):
        w//=i
    return w

n,k=[int(x) for x in raw_input().split()]
ans=0
for i in range(1,n+1):
    pp=1;
    i1=i;
    for j in range(2,i+1):
        sch=0;
        while(i1%j==0):
                sch+=1
                i1//=j
        if (sch):
            pp*=C(sch+k-1,sch)
            pp%=1000000007
    ans+=pp
    ans%=1000000007
print(ans)

from sys import stdin,stdout,setrecursionlimit,maxint,exit
setrecursionlimit(2*10**5)
def listInput():
 return map(long,stdin.readline().split())
def printBS(li):
 if len(li)==0: return
 for i in xrange(len(li)-1):
  stdout.write("%d "%li[i])
 stdout.write("%d\n"%li[-1])
def sin():
 return stdin.readline().rstrip()
n,k=listInput()
MOD=10**9+7
adjList=[[] for i in xrange(n+1)]
for i in xrange(1,n+1):
 for j in xrange(i,n+1,i):
  adjList[i].append(j)
ans=[[0]*(k+1) for i in xrange(n+1)]
for i in xrange(1,n+1):
 ans[i][1]=1
for i in xrange(1,k+1):
 ans[n][i]=1
for i in xrange(n-1,0,-1):
 for j in xrange(2,k+1):
  for l in adjList[i]:
   ans[i][j]=(ans[i][j]+ans[l][j-1])%MOD
pr=0
for i in xrange(1,n+1):
 pr=(pr+ans[i][k])%MOD
print pr

n, k = map(int, raw_input().split())
dp = [[0 for i in range(n + 1)] for j in range(k + 1)]
div = [[] for i in range(n + 1)]
c = 0
for i in range(1, n + 1):
    for j in range(1, i + 1):
        if i % j == 0:
            div[i].append(j)
            c += 1

mod = 10 ** 9 + 7
dp[0][1] = 1
res = 0
for i in range(k):
    for j in range(1, n + 1):
        for x in div[j]:
            dp[i + 1][j] += dp[i][x]
            dp[i + 1][j] %= mod

for x in dp[k]:
    res += x

print res % mod

def solve():

    mod = (10**9) + 7
    n, k = map(int, raw_input().split())

    dp = [1] * n

    for i in xrange(k - 1):
        for j in xrange(1, n+1):
            tmp = 0
            for z in xrange(j, n+1, j):
                tmp = (tmp + dp[z - 1]) % mod
            dp[j - 1] = tmp
    ans = 0
    for i in dp:
        ans = (ans + i) % mod
    print ans
solve()

"Template made by : https://codeforces.com/profile/c1729 , github repo : https://github.com/cheran-senthil/PyRival"
from __future__ import division, print_function
import bisect
import math
import itertools
import sys
from atexit import register

if sys.version_info[0] < 3:
    from io import BytesIO as stream
else:
    from io import StringIO as stream

if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)

        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)

        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)

    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip

def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.

    Args:
        sync (bool, optional): The new synchronization setting.

    """
    global input, flush

    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')

        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
def main():
    n,k = map(int,input().split())
    arr = [1]*2500
    temp = [0]*2500

    summ = 0
    if k<1 or n<1:
        print("0")
    elif k ==1:
        print(n)
    else:
        for j in range(2,k+1):
            for i in range(1,n+1):
                for b in range(i,n+1,i):
                    temp[i] = (temp[i]+arr[b])%1000000007
            for i in range(n+1):
                arr[i] = temp[i]
                temp[i] = 0
        for i in range(1,n+1):
            summ = (summ+arr[i])%1000000007
        print(summ)
if __name__ == '__main__':
    sync_with_stdio(False)
    main()

n,k = map(int, raw_input().split())
final = 0
l = [[0 for i in range(2010)] for j in range(2010)]
for i in range(1,n+1):
    l[1][i] = 1
for i in range(1,k+1):
    for j in range(1,n+1):
        for p in range(j,n+1,j):
            l[i+1][p] = (l[i + 1][p] + l[i][j]) % (10**9+7)
for i in range(1,n+1):
    final = (final+l[k][i])%(10**9+7)
print final

MOD = 10**9+7

def sum(a, b):
	return (a+b)%MOD

n, k = map(int, raw_input().split())

DP = [[]]
DP.append([0] + [1 for i in xrange(1, n+1)])

factors = {}
for i in xrange(1, n+1):
	factors[i] = []
	for j in xrange(1, i+1):
		if i%j == 0:
			factors[i].append(j)

for i in xrange(2, k+1):
	DP.append([0 for _ in xrange(n+1)])
	for j in xrange(1, n+1):
		for f in factors[j]:
			DP[i][j] = (DP[i][j] + DP[i-1][f])%MOD

print reduce(sum, DP[k])

import math
from collections import defaultdict
MOD = 10**9 + 7
def printDivisors(n) :

    i = 1
    Factors = []
    while i <= math.sqrt(n):

        if (n % i == 0) :
            if (n / i == i) :
                Factors.append(i)
            else :
                Factors.append(i)
                Factors.append(int(n/i))
        i = i + 1
    Factors.sort(reverse = True)
    return Factors
F = defaultdict(list)
n,k = map(int,input().split())
for i in range(1,n+1):
    F[i] =printDivisors(i)
dp = [1] * (n+1)
dp[0] = 0
for i in range(1,k):
    for j in range(1,n+1):
        for f in range(j+j,n+1,j):
            dp[j] += dp[f]
            dp[j] %= MOD
print(sum(dp)%MOD)

n, k = map(int, input().split())
dp = [0] * (k + 1)
for i in range(k + 1):
    if i > 0:
        dp[i] = [0] * (n + 1)
    else:
        dp[i] = [1] * (n + 1)
for i in range(1, k + 1):
    for x in range(1, n + 1):
        for j in range(x, n + 1, x):
            dp[i][x] += dp[i - 1][j]
            dp[i][x] %= 1000000007
print(dp[k][1])

import sys
input = sys.stdin.readline
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[1] = 1
for i in range(k):
    tmp = dp.copy()
    dp = [0] * (n + 1)
    for j in range(1, n + 1):
        if tmp[j]:
            for l in range(1, n + 1):
                if j * l <= n:
                    dp[j * l] += tmp[j]
                    dp[j * l] %= MOD
                else:
                    break

print(sum(dp) % MOD)

ans = [[0]*2001 for i in range(2001)]
n, k = [int(x) for x in input().split(' ')] ; p = 0;

for end in range(1, n + 1):
	ans[1][end] = 1

for le in range(2, k + 1):
	for end in range(1, n + 1):
		for nend in range(end, n + 1, end):
			ans[le][nend] = (ans[le - 1][end] + ans[le][nend]) % 1000000007

for i in range(n):
	p = (p + ans[k][i + 1]) % 1000000007
print(p)

mod = 1000000007
n, k = [int(i) for i in input().split()]

factors = []

for i in range(n):
    factors.append([])

for i in range(1, n + 1):
    for j in range(i, n + 1, i):
        factors[j - 1].append(i)
    # print(factors)

# print(factors)

dp = []

for i in range(n):
    dp.append([])

    for j in range(k):
        if i == 0 or j == 0:
            dp[i].append(1)

        else:
            tmp = 0

            for l in factors[i]:
                # print(i, j, l, dp)
                tmp = (tmp + dp[l - 1][j - 1]) % mod
            # print(tmp)
            dp[i].append(tmp)

# print(dp)

good = 0

for i in dp:
    good = (good + i[-1]) % mod

print(good)

#Author: squiggly_lines
#Date: 30/04/2014
#Problem: 414B
import math
def main():
    n,k = map(int, raw_input().split())
    print B(n,k)

def B(n,k):
    s = 0
    for i in xrange(1,n+1):
        s += A(i,k)

    return s

def A(n,k): #Sometimes I forget that code doesn't have to be translated directly ...
    if n == 1:
        return 1
    pf = prime_factor(n)

    prod = 1
    for (p, exp) in pf:
        prod *= binom(exp+k-1, k-1)

    return prod

def prime_factor(n):
    pf = []
    d = 2
    while d**2 <= n:
        exp = 0
        while n % d == 0:
            n /= d
            exp += 1
        if exp > 0:
            pf.append((d,exp)) #The prime doesn't actually matter, but whatever
        d += 1
    if n > 1:
        pf.append((n,1))
    return pf

def binom(n,k): #Because importing itertools or scipy seems overkill
    return reduce(mult, xrange(k+1,n+1)) / reduce(mult, xrange(1,n-k+1))

def mult(x,y): #To compensate for not knowing Python
    return x*y

if __name__ == "__main__":
    main();

from sys import stdin

n, k = map(int, stdin.readline().split())
mem = [0] + [1 for _ in range(n)]

for i in range(1, k):
    for j in range(1, n + 1):
        for d in range(j + j, n + 1, j):
            mem[j] += mem[d]
print(sum(mem))

"""Template for Python Competitive Programmers prepared by Mayank Chaudhary aka chaudhary_19"""

# to use the print and division function of Python3
from __future__ import division, print_function

"""value of mod"""
MOD = 10 ** 9 + 7

"""use resource"""
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])

"""uncomment next 4 lines while doing recursion based question"""
# import threading
# threading.stack_size(2**27)
import sys

# sys.setrecursionlimit(10**6)

"""uncomment next 7 lines while doing nCr question"""
# fact=[1]
# for i in range(1,100001):
#    fact.append((fact[-1]*i)%mod)
# ifact=[0]*100001
# ifact[100000]=pow(fact[100000],mod-2,mod)
# for i in range(100000,0,-1):
#    ifact[i-1]=(i*ifact[i])%mod

"""uncomment modules according to your need"""
from bisect import bisect_left, bisect_right, insort
# import itertools
# import collections
from math import floor, ceil
# import heapq
# from random import randint as rn
# from Queue import Queue as Q

'''
def modinv(n, p):
    return pow(n, p - 2, p)
'''

'''
def ncr(n, r, p):  # for using this uncomment the lines calculating fact and ifact
    t = ((fact[n]) * ((ifact[r] * ifact[n - r]) % p)) % p
    return t
'''

def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()

'''
def GCD(x, y):
    while (y):
        x, y = y, x % y
    return x
'''

"""*******************************************************"""

def get_xor(n):
    return [n,1,n+1,0][n%4]

def count_factors(n, k, dp):

    i = 1
    ans = 0
    while i*i <= n:
        if n%i==0:
            ans += dp[i][k-1]
            if (n//i)!=i:
                ans += dp[n//i][k-1]
        i += 1
    return ans

def main():

    n,k = get_ints()
    dp = [[0 for i in range(n+1)] for j in range(k+1)]

    for i in range(1, k+1):
        dp[i][1] = 1
    for i in range(1, n+1):
        dp[1][i] = 1

    for i in range(2, k+1):
        for j in range(2, n+1):
            # print(i,j, end = ' ')
            ans = 0
            m = 1
            while m*m <= j:
                if j%m==0:
                    ans += dp[i-1][m]
                    if j//m != m:
                        ans += dp[i-1][j//m]
                m += 1
            # print(ans)
            dp[i][j] = ans
    # for i in dp:
    #     print(i)
    print(sum(dp[-1]))

""" -------- Python 2 and 3 footer by Pajenegod and c1729 ---------"""

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip

    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192

class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill();
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

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

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            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 function"""

if __name__ == '__main__':
    main()
# threading.Thread(target=main).start()

"""Template for Python Competitive Programmers prepared by Mayank Chaudhary aka chaudhary_19"""

# to use the print and division function of Python3
from __future__ import division, print_function

"""value of mod"""
MOD = 10 ** 9 + 7

"""use resource"""
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])

"""uncomment next 4 lines while doing recursion based question"""
# import threading
# threading.stack_size(2**27)
import sys

# sys.setrecursionlimit(10**6)

"""uncomment next 7 lines while doing nCr question"""
# fact=[1]
# for i in range(1,100001):
#    fact.append((fact[-1]*i)%mod)
# ifact=[0]*100001
# ifact[100000]=pow(fact[100000],mod-2,mod)
# for i in range(100000,0,-1):
#    ifact[i-1]=(i*ifact[i])%mod

"""uncomment modules according to your need"""
from bisect import bisect_left, bisect_right, insort
# import itertools
# import collections
from math import floor, ceil
# import heapq
# from random import randint as rn
# from Queue import Queue as Q

'''
def modinv(n, p):
    return pow(n, p - 2, p)
'''

'''
def ncr(n, r, p):  # for using this uncomment the lines calculating fact and ifact
    t = ((fact[n]) * ((ifact[r] * ifact[n - r]) % p)) % p
    return t
'''

def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()

'''
def GCD(x, y):
    while (y):
        x, y = y, x % y
    return x
'''

"""*******************************************************"""

def get_xor(n):
    return [n,1,n+1,0][n%4]

def main():

    n,k = get_ints()

    dp = [[0 for i in range(n+1)] for j in range(k+1)]

    store = [[] for i in range(n+1)]
    # print(store)

    for i in range(1, n+1):
        m = 1
        while m*m <= i:
            if i%m==0:
                store[i].append(m)
                if m*m!=i:
                    store[i].append(i//m)
            m += 1

    for i in range(1, k+1):
        for j in range(1, n+1):
            if i==1 or j==1:
                dp[i][j] = 1
            else:
                ans = 0
                for m in store[j]:
                    ans += dp[i-1][m]
                dp[i][j] = ans

    # for i in dp:
    #     print(i)
    print(sum(dp[-1]))

""" -------- Python 2 and 3 footer by Pajenegod and c1729 ---------"""

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip

    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192

class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill();
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

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

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            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 function"""

if __name__ == '__main__':
    main()
# threading.Thread(target=main).start()

n,k=map(int,raw_input().split())
dict={}
for i in range(1,n+1):
    dict[i]=[]
for i in range(1,n+1):
    j=i
    while(j>0):
        if i%j==0:
            dict[i].append(j)
        j-=1
arr=[[0 for i in range(n+1)] for j in range(k+1)]
for i in range(1,n+1):
    arr[1][i]=1
for i in range(2,k+1):
    for j in range(1,n+1):
        s=0
        for p in dict[j]:
            s+=arr[i-1][p]
        arr[i][j]=s
print sum(arr[k])

n, k = map(int, raw_input().split())
dp = [[0 for i in range(n + 1)] for j in range(k + 1)]
div = [[] for i in range(n + 1)]
c = 0
for i in range(1, n + 1):
    for j in range(1, i + 1):
        if i % j == 0:
            div[i].append(j)
            c += 1

print(c)
mod = 10 ** 9 + 7
dp[0][1] = 1
res = 0
for i in range(k):
    for j in range(1, n + 1):
        for x in div[j]:
            dp[i + 1][j] += dp[i][x]
            dp[i + 1][j] %= mod

for x in dp[k]:
    res += x

print res % mod

n, k = map(int, raw_input().split())

DP = [[]]
DP.append([0] + [1 for i in xrange(1, n+1)])

factors = {}
for i in xrange(1, n+1):
	factors[i] = []
	for j in xrange(1, i+1):
		if i%j == 0:
			factors[i].append(j)

for i in xrange(2, k+1):
	DP.append([0 for _ in xrange(n+1)])
	for j in xrange(1, n+1):
		for f in factors[j]:
			DP[i][j] += DP[i-1][f]

print sum(DP[k])

Mod=10**+7
n,k=map(int,input().split())
dp=[[0]*(n+1) for i in range(k+1)]
l=[[] for _ in range(n+1)]
for i in range(1,n+1):
    dp[1][i]=1
    for j in range(1,i+1):
        if i%j==0:
            l[i].append(j)
for j in range(2,k+1):
    for i in range(1,n+1):
        for le in range(len(l[i])):
            dp[j][i]+=dp[j-1][l[i][le]]
            dp[j][i]%=Mod
ans=0
for i in range(1,n+1):
    ans+=dp[k][i]
    ans%=Mod
print(ans)

import math
a=list(map(int,input().split()))
dp=[[0 for i in range(a[1]+1)]for j in range(a[0]+1)]
for i in range(1,a[0]+1):
    dp[i][0]=1
for i in range(1,a[0]//2+1):
    dp[i][1]=(a[0]//i-1)

for j in range(2,a[1]+1):
    for i in range(1,(a[0]//(2**j))+1):
        for l in range(2*i,(a[0]//(i))+1,i):
            dp[i][j]+=dp[l][j-1]

cnt=a[0]
mod=1000000007
arr=[0 for i in range(a[1]+1)]
for i in range(1,a[1]):
    for j in range(1,a[0]//2+1):
        arr[i]+=dp[j][i]
ans=1
for i in range(1,a[1]-1):
    ans1=1
    for q in range(1,i+1):
        ans1=ans1*(a[1]-q)
    ans2=1
    for j in range(1,i+1):
        ans2=ans2*j
    ans=ans1//ans2
    cnt=cnt%mod+(arr[i]*ans)%mod
    cnt=cnt%mod

cnt=cnt%mod+arr[a[1]-1]%mod
print(cnt%mod)

import math
a=list(map(int,input().split()))
dp=[[0 for i in range(a[1]+1)]for j in range(a[0]+1)]
for i in range(1,a[0]+1):
    dp[i][0]=1
for i in range(1,a[0]//2+1):
    dp[i][1]=(a[0]//i-1)

for j in range(2,a[1]+1):
    for i in range(1,(a[0]//(2**j))+1):
        for l in range(2*i,(a[0]//(i*j))+1,i):
            dp[i][j]+=dp[l][j-1]

cnt=a[0]
mod=1000000007
arr=[0 for i in range(a[1]+1)]
for i in range(1,a[1]):
    for j in range(1,a[0]//2+1):
        arr[i]+=dp[j][i]
ans=1
for i in range(1,a[1]-1):
    ans1=1
    for q in range(1,i+1):
        ans1=ans1*(a[1]-q)
    ans2=1
    for j in range(1,i+1):
        ans2=ans2*j
    ans=ans1//ans2
    cnt=cnt%mod+(arr[i]*ans)%mod
    cnt=cnt%mod

cnt=cnt%mod+arr[a[1]-1]%mod
print(cnt%mod)

import math
a=list(map(int,input().split()))
dp=[[0 for i in range(a[1]+1)]for j in range(a[0]+1)]
for i in range(1,a[0]+1):
    dp[i][0]=1
for i in range(1,a[0]//2+1):
    dp[i][1]=(a[0]//i-1)

for j in range(2,a[1]+1):
    for i in range(1,(a[0]//(2**j))+1):
        for l in range(2*i,(a[0]//(i**(j-1)))+1  ,i):
            dp[i][j]+=dp[l][j-1]

cnt=a[0]
mod=1000000007
arr=[0 for i in range(a[1]+1)]
for i in range(1,a[1]):
    for j in range(1,a[0]//2+1):
        arr[i]+=dp[j][i]
ans=1
for i in range(1,a[1]-1):
    ans1=1
    for q in range(1,i+1):
        ans1=ans1*(a[1]-q)
    ans2=1
    for j in range(1,i+1):
        ans2=ans2*j
    ans=ans1//ans2
    cnt=cnt%mod+(arr[i]*ans)%mod
    cnt=cnt%mod

cnt=cnt%mod+arr[a[1]-1]%mod
print(cnt%mod)

import math
a=list(map(int,input().split()))
dp=[[0 for i in range(a[1]+1)]for j in range(a[0]+1)]
for i in range(1,a[0]+1):
    dp[i][0]=1
for i in range(1,a[0]//2+1):
    dp[i][1]=(a[0]//i-1)

for j in range(2,a[1]+1):
    for i in range(1,a[0]//2+1):
        if(i>=2):

            r=int(math.log(a[0])//math.log(i))+1
        else:
            r=a[0]+1
        for l in range(2*i,r,i):
            dp[i][j]+=dp[l][j-1]

cnt=a[0]
mod=1000000007
arr=[0 for i in range(a[1]+1)]
for i in range(1,a[1]):
    for j in range(1,a[0]//2+1):
        arr[i]+=dp[j][i]
ans=1
for i in range(1,a[1]-1):
    ans1=1
    for q in range(1,i+1):
        ans1=ans1*(a[1]-q)
    ans2=1
    for j in range(1,i+1):
        ans2=ans2*j
    ans=ans1//ans2
    cnt=cnt%mod+(arr[i]*ans)%mod
    cnt=cnt%mod

cnt=cnt%mod+arr[a[1]-1]%mod
print(cnt%mod)

n, k = map(int, input().split())
p = [0, 0] + [[1] * k for i in range(n - 1)]
n += 1
for i in range(2, n):
    for j in range(k - 1): p[i][j + 1] += p[i][j]
    for j in range(2 * i, n, i):
        for d in range(k - 1): p[j][d + 1] += p[i][d]
print(sum(r[k - 1] for r in p[2: ]) + 1)

n, k = map(int, input().split())
p = [0, 0] + [[1] * k for i in range(n - 1)]
d, n = 1000000007, n + 1
for i in range(2, n):
    for j in range(k - 1): p[i][j + 1] = (p[i][j + 1] + p[i][j]) % d
    for j in range(2 * i, n, i):
        for d in range(k - 1): p[j][d + 1] += p[i][d]
print((sum(r[k - 1] for r in p[2: ]) + 1) % d)

import math

MOD = 10**9 + 7

def count_good_sequences(n, k):

    good_sequences = 1

    for i in xrange(2, n + 1):
        factorization = prime_factorize(i)
        s_i = 1
        for prime in factorization:
            num_factors = factorization[prime]
            result = 0
            for e_i in xrange(num_factors + 1):
                result = (result + choose_mod(fact, inv_fact, e_i + k - 2, k - 2, MOD)) % MOD
            s_i = (s_i * result) % MOD
        good_sequences = (good_sequences + s_i) % MOD

    return good_sequences

def prime_factorize(n):

    factors = {}
    prime = 3

    while n > 0 and n % 2 == 0:
        if 2 not in factors:
            factors[2] = 0
        factors[2] += 1
        n = n/2

    while prime <= math.sqrt(n):
        while n % prime == 0:
            if prime not in factors:
                factors[prime] = 0
            factors[prime] += 1
            n = n/prime
        prime += 2

    if n > 2:
        factors[n] = 1

    return factors

def generate_factorial(n, p):

    fact = [1]
    inv_fact = [1]

    for i in xrange(1, n + 1):
        fact.append((fact[-1]*i) % p)
        inv_fact.append(extended_euclidean(fact[-1], p)[0] % p)

    return fact, inv_fact

def extended_euclidean(a, b):

    if a == 0:
        return (0, 1, b)

    a = abs(a)
    b = abs(b)
    a, b = min(a, b), max(a, b)
    x, y, gcd = extended_euclidean(b % a, a)
    x, y = y - (b/a)*x, x
    return (x, y, gcd)

def choose_mod(fact, inv_fact, n, k, p):

    if n < k: return 0
    return (((fact[n]*inv_fact[n - k]) % p)*inv_fact[k]) % p

n, k = map(int, raw_input().strip().split(' '))
fact, inv_fact = generate_factorial(10000, MOD)
print count_good_sequences(n, k)

'''
	CodeForces 414B
	Mashmokh and ACM

	Tags: dp, Math
'''

MOD = 1000000007

n, k = tuple(map(int, input().split()))

divider = [ [ x for x in range(1, n + 1) if i % x == 0 ] for i in range(n + 1) ]

print(divider)

dp = [ [ 1 for j in range(k + 1) ] for i in range(n + 1) ]

for j in range(2, k + 1):
	for i in range(1, n + 1):
		dp[i][j] = sum(map(lambda x: dp[x][j - 1], divider[i])) % MOD

ans = sum([ dp[i][k] for i in range(1, n + 1) ]) % MOD
print(ans)

# SHRi GANESHA    author: Kunal Verma #

import os,sys
from collections import Counter, deque
from io import BytesIO, IOBase

def main():
    import math

    n, k = map(int, input().split())
    mod = 10 ** 9 + 7

    def divisors(n):
        i = 1
        x = []
        while i <= math.sqrt(n):
            if (n % i == 0):
                if (n // i == i):
                    x.append(i)
                else:
                    x.append(i)
                    x.append(n // i)
            i = i + 1
        return x

    dp = [[0 for i in range(n)] for j in range(k)]
    x = [0 for i in range(n + 1)]
    for i in range(1, n + 1):
        x[i] = divisors(i)

    for i in range(n):
        dp[0][i] = 1
    for i in range(k):
        for j in range(n):
            for p in x[j + 1]:
                dp[i][j] = (dp[i][j] + dp[i - 1][p - 1]) % mod
    print(sum(dp[k - 1]) % mod)
#Fast IO Region
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")

if __name__ == '__main__':
    main()

# SHRi GANESHA    author: Kunal Verma #

import os,sys
from collections import Counter, deque
from io import BytesIO, IOBase

def main():
    import math

    n, k = map(int, input().split())
    mod = 10 ** 9 + 7

    def divisors(n):
        i = 1
        x = []
        while i <= math.sqrt(n):
            if (n % i == 0):
                if (n // i == i):
                    x.append(i)
                else:
                    x.append(i)
                    x.append(n // i)
            i = i + 1
        return x

    dp = [[0 for i in range(n)] for j in range(k)]
    x = [0 for i in range(n + 1)]
    for i in range(1, n + 1):
        x[i] = divisors(i)
    print(x)
    for i in range(n):
        dp[0][i] = 1
    for i in range(k):
        for j in range(n):
            for p in x[j + 1]:
                dp[i][j] = (dp[i][j] + dp[i - 1][p - 1]) % mod
    print(sum(dp[k - 1]) % mod)
#Fast IO Region
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")

if __name__ == '__main__':
    main()

n,m=map(int,input().split())
a=[]
for i in range(1,n+1):
    a.append(n//i)
if(m==1):
    print(n)
else:
    for x in range(m-2):
        for i in range(1,n+1):
            j=i
            while(j<=n):
                j+=i
                if(j<=n):
                    a[i-1]+=a[j-1]
    print(sum(a))

import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
mod = 10**9 + 7
n, k = map(int, input().split())
count = [1]*(n+1)
for i in range(k-1):
	new = [0]*(n+1)
	for j in range(1, n+1):
		t = count[j]
		for k in range(j, n+1, j):
			new[k] = (new[k]+t)%mod
	count = new
print(sum(count)%mod)

n,k = map(int,input().split())
l = [int(n/i) for i in range(1,n+1)]
mod = 1000000007
if k == 1 :
	print(n)
else :
	p = 2
	while p <= k -2 :
		i = 1
		while(i <= n) :
			j=1
			while(j*i <= n) :
				l[i-1] = (l[i-1] + l[j*i-1])%mod
				j += 1
			i +=1
		p += 1

	print(sum(l)%mod)

n, k = map(int, input().rstrip().split(" "))
l = [n//i for i in range(1,n+1)]
if k ==1 :
    print(n)
else:
    for i in range(0,k-2):
        for j in range(1, n+1):
            x=j
            while x<=n:
                x += j
                if x<=n:
                    l[j-1]= (l[j-1] + l[x-1])%(10**8 + 7)

    print(sum(l))

n, k = map(int, input().split())
MOD = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[1] = 1
for i in range(k):
    tmp = dp.copy()
    dp = [0] * (n + 1)
    for j in range(1, n + 1):
        if tmp[j]:
            for l in range(1, n + 1):
                if j * l <= n:
                    dp[j * l] += tmp[j]
                    dp[j * l] %= MOD
                else:
                    break

print(sum(dp))

import math
n, k = map(int, input().split())
dp = [[0]*(n+1) for _ in range(k+1)]
dp[0][1] = 1
for i in range(1, k+1):
    for j in range(1, n+1):
        for m in range(j, n+1, j):
            dp[i][m] += dp[i-1][j]
ans = 0
for i in range(1, n+1):
    ans += (dp[k][i])%1000000007
print(ans)

import math
n, k = map(int, input().split())
dp = [[0]*(n+1) for _ in range(k+1)]
dp[0][1] = 1
for i in range(1, k+1):
    for j in range(1, n+1):
        for m in range(j, n+1, j):
            dp[i][m] = (dp[i][k] + dp[i-1][j])%1000000007
ans = 0
for i in range(1, n+1):
    ans = (ans+dp[k][i])%1000000007
print(ans)

import math
n, k = map(int, input().split())
dp = [[1 for _ in range(k+1)] for _ in range(n+1)]
for i in range(1, n+1):
    f = set((1, i))
    for m in range(2, int(math.sqrt(i))+1):
        if i%m==0:
            f.add(m)
            if i/m != i:
                f.add(i//m)
    for j in range(2, k+1):
        dp[i][j] = 0
        for x in f:
            dp[i][j] += dp[x][j-1]
ans = 0
for i in range(1, n+1):
    ans += dp[i][k]
print(ans)

import math
n, k = [*map(int, input().split())]

prime = [1]
f = [False] * 2000
for i in range(2, 2000):
    if f[i]:
        continue
    f[i] = True
    prime.append(i)
    j = 1
    while i * j < 2000:
        f[i * j] = True
        j += 1

f = [[0] * (n + 1) if i != 1 else [1] * (n + 1) for i in range(k + 1)]
div = [[]]
f[1][0] = 0
for i in range(1, n + 1):
    j = 0
    div.append([])
    while prime[j] <= math.sqrt(i):
        if not (i % prime[j]):
            div[i] += [prime[j]]
            if i // prime[j] != prime[j]:
                div[i] += [i // prime[j]]
        j += 1
    for j in range(2, k + 1):
        for l in div[i]:
            f[j][i] += f[j - 1][i // l]
            f[j][i] %= 10 ** 9 + 7
ans = 0
for i in f[k]:
    ans += i
    ans %= 10 ** 9 + 7
print(ans)

mod=10**9+7
[n ,k]=list(map(int, input().split()))
dp=[[0 for _ in range(n+1)] for _ in range(k+1)]
for last in range(1, n+1):
    dp[1][last]=1
for l in range(2, k+1):
    for i in range(1, n+1):
        for j in range(i, n+1, i):
            dp[l][j]=(dp[l][j]+dp[l-1][i])%mod
print(sum(dp[k]))

mod = 10**9 + 7
n, t = map(int, input().split())
dp = [[0 for i in range(2016)] for j in range(2016)]
dp[0][1] = 1
for i in range(1, t+1):
    for j in range(1, n+1):
        for k in range(j, n+1, j):
            dp[i][k] += dp[i-1][j]
            dp[i][k] %= mod
ans = 0
for i in range(1, n+1):
    ans += (dp[t][i])%mod
print(ans)

mod = 10**9 + 7
n, t = map(int, input().split())
dp = [[0 for i in range(2016)] for j in range(2016)]
dp[0][1] = 1
for i in range(1, t+1):
    for j in range(1, n+1):
        for k in range(j, n+1, j):
            dp[i][k] += (dp[i-1][j])
            dp[i][k] %= mod
ans = 0
for i in range(1, n+1):
    ans += dp[t][i]
print(ans)

import sys
import math as mt
input=sys.stdin.buffer.readline
t=1
mod=10**9+8
for __ in range(t):
    n,k=map(int,input().split())
    dp=[[0 for j in range(k+1)] for i in range(n+1)]
    pre=[[0 for j in range(k+1)] for i in range(n+1)]
    for i in range(1,n+1):
        dp[i][1]=i
        pre[i][1]=i
    for i in range(1,k+1):
        dp[1][i]=1
        pre[1][i]=(pre[1][i-1]%mod+dp[1][i]%mod)%mod
    for i in range(2,n+1):
        j1=1
        for i1 in range(1,i):
            if i%i1==0:
                j1=i1

        for j in range(2,k+1):
            dp[i][j]=(dp[i-1][j]%mod+1+pre[j1][j-1]%mod)%mod
            pre[i][j]=(pre[i][j-1]%mod+dp[i][j]%mod)%mod
    #print(dp)
    print(dp[n][k])

n, k = map(int, input().strip().split())
dp = [[0 for i in range(n)] for i in range(k)]
for i in range(n):
    dp[0][i] = 1

for i in range(k-1):
    for j in range(n):
        for p in range(j+1, n+1, j+1):
            dp[i+1][p-1] += dp[i][j]
# print('----')
# for i in dp:
#     print(i)
print(sum(dp[-1]))

mod = 10**9+7
n, k = map(int, input().strip().split())
dp = [[0 for i in range(n)] for i in range(k)]
for i in range(n):
    dp[0][i] = 1

for i in range(k-1):
    for j in range(n):
        for p in range(j+1, n+1, j+1):
            dp[i+1][p-1] = (dp[i+1][p-1] + dp[i][j])%mod
# print('----')
# for i in dp:
#     print(i)
print(sum(dp[-1]))

n,k=map(int,input().split())
m=10**9+7
dp=[[1 if i==1 else 0 for i in range(k+1)]for j in range(n+1)]
for j in range(1,k):
  for i in range(1,n+1):
    for ii in range(i,n+1,i):
      dp[ii][j+1]=(dp[ii][j+1]%m+dp[i][j]%m)%m
sums=0
#for i in range(1,n+1):
#  sums=(sums%m+dp[i][k]%m)%m
ans = sum([ dp[i][k] for i in range(1, n + 1) ]) % m
print(sums%m)

n,k1 = map(int,input().split())

dp = [[0 for i in range(n+1)] for j in range(k1+1)]
dp[0][0] = 1
for i in range(k1+1):

	dp[i][0] = 1

# for i in range(n+1):

# 	dp[i][0] = 1

for i in range(1,n+1):

	dp[1][i] = 1

# print(dp)

for i in range(2,k1+1):

	for j in range(1,n+1):
		k = j
		# r = j
		# print("--")
		while k <= n:

			dp[i][k] = dp[i][k] + dp[i-1][j]

			k = k + j
# print(dp)
print(sum(dp[k1])-1)

# print(dp)
# print(dp[n][k])

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

d = []

for i in range(1,2001):
    cur = []
    for j in range(1,i+1):
        if i%j==0:
            cur.append(j)
    d.append(cur)

dp = []

for i in range(0,k+1):
    cur=[]
    for j in range(0, n+1):
        cur.append(0)
    dp.append(cur)

for i in range(1,n+1):
    dp[1][i] = 1

for i in range(1,k+1):
    for j in range(1,n+1):
        for c in d[j-1]:
            dp[i][j]+=dp[i-1][c]

ans = 0

for i in range(1,n+1):
    ans+=dp[k][i]

print(ans)

from sys import stdin
import time

n, k = map(int, stdin.readline().rstrip().split(" "))

d = [{} for i in range(k)]

divisors = []

for i in range(n + 1):
    temp = []
    for j in range(1, i + 1):
        if i % j == 0:
            temp.append(j)
    divisors.append(temp)

def getAns(pos, dig):
    #print(pos, dig)
    if pos == 0:
        return 1
    if dig in d[pos]:
        return d[pos][dig]
    else:
        temp = 0
        for di in divisors[dig]:
            temp += getAns(pos - 1, di)
        d[pos][dig] = temp
        return temp

#print(divisors)
answer = 0
for i in range(1, n + 1):
    answer += getAns(k - 1, i)
#print(d)
print(answer % int(10e9 + 7))

from sys import stdin
import time

n, k = map(int, stdin.readline().rstrip().split(" "))

d = [{} for i in range(k)]

divisors = []

for i in range(n + 1):
    temp = []
    for j in range(1, i + 1):
        if i % j == 0:
            temp.append(j)
    divisors.append(temp)

def getAns(pos, dig):
    #print(pos, dig)
    if pos == 0:
        return 1
    if dig in d[pos]:
        return d[pos][dig]
    else:
        temp = 0
        for di in divisors[dig]:
            temp += getAns(pos - 1, di)
        d[pos][dig] = temp
        return temp

#print(divisors)
answer = 0
for i in range(1, n + 1):
    answer += getAns(k - 1, i)
#print(d)
print(answer)

from sys import stdin
from collections import  defaultdict
import time

K = int(10e8 + 7)
n, k = map(int, stdin.readline().rstrip().split(" "))

lc = [0] * (n + 1)
lp = [1] * (n + 1)

for i in range(1, k):
    for j in range(1, n + 1):
        m = 1
        while j * m <= n:
            lc[j * m] = (lc[j * m] + lp[j]) % K
            m += 1
    lp = lc.copy()
    lc = [0] * (n + 1)

print(sum(lp) % K)

from sys import stdin
from collections import  defaultdict
import time

n, k = map(int, stdin.readline().rstrip().split(" "))

d = [defaultdict(lambda : 0) for i in range(k)]

divisors = []

for i in range(n + 1):
    temp = []
    for j in range(1, i + 1):
        if i % j == 0:
            temp.append(j)
    divisors.append(temp)

for i in range(n):
    d[0][i + 1] = 1

for i in range(1, k):
    for j in range(n + 1):
        for div in divisors[j]:
            d[i][j] += d[i - 1][div]

#print(d)
print(sum(d[k - 1].values()))

n, k = [int(i) for i in input().split()]

factors = []

for i in range(n):
    factors.append([])

for i in range(1, n + 1):
    for j in range(i, n + 1, i):
        factors[j - 1].append(i)
    # print(factors)

# print(factors)

dp = []

for i in range(n):
    dp.append([])

    for j in range(k):
        if i == 0 or j == 0:
            dp[i].append(1)

        else:
            tmp = 0

            for l in factors[i]:
                # print(i, j, l, dp)
                tmp += dp[l - 1][j - 1]
            # print(tmp)
            dp[i].append(tmp)

# print(dp)

good = 0

for i in dp:
    good += i[-1]

print(good)

import math
n, k = map(int, input().split())
dp = [[0]*(n+1) for _ in range(k+1)]
MOD=10**9+7
dp[0][1] = 1
for i in range(1, k+1):
    for j in range(1, n+1):
        for m in range(j, n+1, j):
            dp[i][m] = (dp[i][m] + dp[i-1][j])%MOD
ans = 0
for i in range(1,n+1):
    ans+=dp[k][i]%MOD
print(ans)

import math
n, k = map(int, input().split())
dp = [[0]*(n+1) for _ in range(k+1)]
MOD=10**9+7
dp[0][1] = 1
for i in range(1, k+1):
    for j in range(1, n+1):
        for m in range(j, n+1, j):
            dp[i][m] = (dp[i][m] + dp[i-1][j])%MOD
ans = 0
for i in dp:
    print(i)
print(ans)

n, k = [int(i) for i in input().split()]
dp = [[-1]*(n+1) for i in range(n+1)]
def solve(x,k):
    if(k==0):
        return 1
    elif(dp[x][k]!=-1):
        return dp[x][k]
    ans=0
    for i in range(x,n+1,x):
        ans+=solve(i,k-1)
    dp[x][k]=ans
    return dp[x][k]
res=solve(1,k)
print(res)

import math
n, k = map(int, input().split())
dp = [[0]*(n+1) for _ in range(k+1)]
MOD=10**9+7
dp[0][1] = 1
for i in range(1, k+1):
    for j in range(1, n+1):
        for m in range(j, n+1, j):
            dp[i][m] = (dp[i][m] + dp[i-1][j])%MOD
ans = 0
print(ans)

n, k = [int(i) for i in input().split()]
dp = [[-1]*(2005) for i in range(2005)]
def solve(x,k):
    if(k==0):
        return 1
    elif(dp[x][k]!=-1):
        return dp[x][k]
    ans=0
    for i in range(x,n+1,x):
        ans+=solve(i,k-1)
    dp[x][k]=ans
    return dp[x][k]
res=solve(1,k)
print(res)