Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced programmer. Actually he is not a programmer at all. So he wasn't able to solve them. That's why he asked you to help him with these tasks. One of these tasks is the following.

A sequence of l integers b1, b2, ..., bl (1 ≤ b1 ≤ b2 ≤ ... ≤ bl ≤ n) is called good if each number divides (without a remainder) by the next number in the sequence. More formally <image> for all i (1 ≤ i ≤ l - 1).

Given n and k find the number of good sequences of length k. As the answer can be rather large print it modulo 1000000007 (109 + 7).

Input

The first line of input contains two space-separated integers n, k (1 ≤ n, k ≤ 2000).

Output

Output a single integer — the number of good sequences of length k modulo 1000000007 (109 + 7).

Examples

Input

3 2


Output

5


Input

6 4


Output

39


Input

2 1


Output

2

Note

In the first sample the good sequences are: [1, 1], [2, 2], [3, 3], [1, 2], [1, 3].

Source: codeforces | Difficulty: MEDIUM
Tags: Number theory

Combinatorics

Dynamic programming


Solutions:
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)


(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
ans = sum([dp[i][k] for i in range(1, n + 1)]) % m
print(ans % m)


(n, k) = map(int, input().split())
mod = 10 ** 9 + 7
l = [[] for i in range(2 * 10 ** 3 + 1)]
for i in range(1, 2 * 10 ** 3 + 1):
	for j in range(1, i + 1):
		if i % j == 0:
			l[i].append(j)
dp = [[0] * (n + 1) for i in range(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 x in l[j]:
			dp[i][j] += dp[i - 1][j // x]
			dp[i][j] %= mod
print(sum(dp[-1]) % mod)


MOD = 10 ** 9 + 7
(n, k) = map(int, input().split())
e = []

def addMod(a, b):
	if a + b < MOD:
		return a + b
	else:
		return a + b - MOD
for i in range(1, n + 1):
	for j in range(i, n + 1, i):
		e.append((i, j))
dp = [i > 0 for i in range(0, n + 1)]
for i in range(1, k):
	ndp = [0 for j in range(0, n + 1)]
	for (a, b) in e:
		ndp[b] = addMod(ndp[b], dp[a])
	dp = ndp.copy()
print(sum(dp) % MOD)


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][m] + dp[i - 1][j]) % 1000000007
ans = 0
for i in range(1, n + 1):
	ans = (ans + dp[k][i]) % 1000000007
print(ans)


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


from sys import stdin, stdout
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	(n, k) = lst()
	M = 10 ** 9 + 7
	ans = 0
	dp = [[0 for i in range(k + 1)] for _ in range(n + 1)]
	for j in range(1, k + 1):
		for i in range(1, n + 1):
			if j == 1:
				dp[i][j] = 1
			for mul in range(i, n + 1, i):
				dp[i][j] = (dp[i][j] + dp[mul][j - 1]) % M
	for i in range(1, n + 1):
		ans = (ans + dp[i][k]) % M
	print(ans)


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


def C(n, m):
	a = 1
	for i in range(n - m + 1, n + 1):
		a *= i
	for i in range(1, m + 1):
		a //= i
	return a
(n, k) = map(int, input().split())
a = 0
for i in range(1, n + 1):
	t = 1
	I = i
	for j in range(2, i + 1):
		s = 0
		while I % j == 0:
			s += 1
			I //= j
		if s:
			t *= C(s + k - 1, s)
	a += t
print(a % (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
for i in range(1, k + 1):
	for j in range(1, n + 1):
		temp = j
		while temp <= n:
			a[i][temp] += a[i - 1][j]
			a[i][temp] %= 1000000007
			temp += j
print(sum(a[k - 1]) % 1000000007)


mod = 10 ** 9 + 7
(n, k) = map(int, 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 length in range(2, k + 1):
	for j in range(1, n + 1):
		for end in range(j, n + 1, j):
			dp[length][end] = (dp[length][end] + dp[length - 1][j]) % mod
print(sum(dp[k]) % mod)


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


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


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)


from os import path
import sys, time
mod = int(1000000000.0 + 7)
from math import ceil, floor, gcd, log, log2, factorial, sqrt
from collections import defaultdict, Counter, OrderedDict, deque
from itertools import combinations, permutations
from string import ascii_lowercase, ascii_uppercase
from bisect import *
from functools import reduce
from operator import mul
maxx = float('inf')
I = lambda : int(sys.stdin.buffer.readline())
lint = lambda : [int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda : sys.stdin.readline().strip('\n')
grid = lambda r: [lint() for i in range(r)]
localsys = 0
start_time = time.time()
nCr = lambda n, r: reduce(mul, range(n - r + 1, n + 1), 1) // factorial(r)

def ceill(n, x):
	return (n + x - 1) // x
T = 0

def solve():
	(n, k) = lint()
	dp = [[0 for i in range(n + 1)] for _ in range(k + 1)]
	for l in range(1, n + 1):
		dp[1][l] += 1
	for length in range(2, k + 1):
		for j in range(1, n + 1):
			for end in range(j, n + 1, j):
				dp[length][end] = (dp[length][end] + dp[length - 1][j]) % mod
	print(sum(dp[k]) % mod)

def run():
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
run()
T = I() if T else 1
for _ in range(T):
	solve()
if localsys:
	print('\n\nTime Elased :', time.time() - start_time, 'seconds')


(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, 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(1, n + 1):
	dp[1][i] = 1
for i in range(2, k1 + 1):
	for j in range(1, n + 1):
		k = j
		while k <= n:
			dp[i][k] = (dp[i][k] + dp[i - 1][j]) % 1000000007
			k = k + j
print((sum(dp[k1]) - 1) % 1000000007)


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:
		res = res * (comb(i, k + i - 1) % N) % N
	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)


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


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


MOD = 1000000007
MOD2 = 998244353
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, k) = f()
dp = [[0 for _ in range(n + 1)] for __ in range(k + 1)]
for i in range(1, n + 1):
	dp[1][i] = 1
for i in range(1, k):
	for j in range(1, n + 1):
		for x in range(j, n + 1, j):
			dp[i + 1][x] += dp[i][j]
			dp[i + 1][x] %= MOD
ans = 0
for i in range(n + 1):
	ans += dp[k][i]
	ans %= MOD
print(ans)


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)


from __future__ import print_function
import sys
from collections import *
from heapq import *
from functools import *
INF = float('inf')
NINF = float('-inf')
try:
	input = raw_input
except:
	pass

def read_string():
	return input()

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

def read_int():
	return int(input())

class TreeNode(object):

	def __init__(self, x):
		self.val = x
		self.left = None
		self.right = None

	def __str__(self):
		q = deque()
		ans = []
		q.append(self)
		ans.append(self.val)
		while q:
			cur = q.popleft()
			ans.append(cur.left.val if cur.left else 'null')
			ans.append(cur.right.val if cur.right else 'null')
			if cur.left:
				q.append(cur.left)
			if cur.right:
				q.append(cur.right)
		while ans and ans[-1] == 'null':
			ans.pop()
		return str(ans).replace("'null'", 'null')

def toTreeNode(s):
	l = eval(s.replace('null', 'None'))
	n = len(l)
	if not n:
		return None
	root = TreeNode(l[0])
	q = deque()
	q.append(root)
	i = 1
	while q and i < n:
		cur = q.popleft()
		if l[i] != None:
			cur.left = TreeNode(l[i])
			q.append(cur.left)
		i += 1
		if i >= n:
			break
		if l[i] != None:
			cur.right = TreeNode(l[i])
			q.append(cur.right)
		i += 1
	return root

class Djs:

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

	def find(self, x):
		p = self.p[x]
		if p == -1:
			return x
		else:
			self.p[x] = self.find(p)
			return self.p[x]

	def union(self, x, y):
		(x, y) = (self.find(x), self.find(y))
		if x == y:
			return
		if self.w[x] > self.w[y]:
			(x, y) = (y, x)
		self.p[x] = y
		self.w[y] += self.w[x]

	def roots(self):
		return [x for (x, y) in enumerate(self.p) if y == -1]

def doit():
	(n, k) = read_int_line()
	dp = [[0] * (n + 1) for _ in range(k + 1)]
	factors = [[] for _ in range(n + 1)]
	for i in range(1, n + 1):
		j = i
		while j <= n:
			factors[j].append(i)
			j += i
	P = 10 ** 9 + 7
	for ni in range(1, n + 1):
		dp[1][ni] = 1
	for ki in range(2, k + 1):
		for ni in range(1, n + 1):
			for fi in factors[ni]:
				dp[ki][ni] = (dp[ki][ni] + dp[ki - 1][fi]) % P
	ans = sum(dp[k]) % P
	print('%d' % ans)
try:
	while True:
		doit()
except EOFError:
	pass


x = input().split(' ')
n = int(x[0])
k = int(x[1])
if k == 1:
	print(n)
else:
	l = []
	for i in range(k):
		if i == 0:
			a = []
			for j in range(n):
				a.append(1)
			l.append(a)
		else:
			b = []
			for p in range(n):
				b.append(0)
			l.append(b)
	for i in range(1, k):
		for j in range(1, n + 1):
			for m in range(j, n + 1, j):
				l[i][m - 1] += l[i - 1][j - 1]
				l[i][m - 1] %= 1000000007
	print(sum(l[k - 1][:n]) % 1000000007)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(1):
	(n, k) = l()
	dp = [[0 for i in range(2016)] for j in range(2016)]
	dp[0][1] = 1
	for i in range(1, k + 1):
		for j in range(1, n + 1):
			for x in range(j, n + 1, j):
				dp[i][x] = (dp[i][x] + dp[i - 1][j]) % mod
	ans = 0
	for i in range(1, n + 1):
		ans += dp[k][i]
		ans = ans % mod
	print(ans)


import sys
from math import *
import threading
from itertools import count
from pprint import pprint
from heapq import heapify, heappop, heappush
sys.setrecursionlimit(300000)
mod = 10 ** 9 + 7
inf = 10 ** 15
decision = ['NO', 'YES']
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

def npr(n, r):
	return factorial(n) // factorial(n - r) if n >= r else 0

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val):
	ans = -1
	lb = 0
	ub = len(li) - 1
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = mid
			break
	return ans

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum

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

def primefactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n //= 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n //= i
	if n > 2:
		factors.append(n)
	return factors

def prod(li):
	ans = 1
	for i in li:
		ans *= i
	return ans
for _ in range(1):
	(n, k) = map(int, input().split())
	dp = [[0 for j in range(n)] for i in range(k)]
	for j in range(n):
		dp[0][j] = 1
	for i in range(1, k):
		for j in range(1, n + 1):
			for l in range(j, n + 1, j):
				dp[i][j - 1] += dp[i - 1][l - 1] % mod
				dp[i][j - 1] %= mod
	ans = 0
	for i in dp[-1]:
		ans += i % mod
		ans %= mod
	print(ans)


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


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)


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)


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
dp = [[0] * (n + 1) for _ in range(k + 1)]
for i in range(n + 1):
	dp[0][i] = 1
MOD = 1000000000 + 7
for i in range(1, k + 1):
	for l in range(1, n + 1):
		for j in range(l, n + 1, l):
			dp[i][l] += dp[i - 1][j]
			dp[i][l] %= MOD
print(dp[k][1])


import math
from collections import defaultdict
MOD = 10 ** 9 + 7
(n, k) = map(int, input().split())
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])


MOD = 10 ** 9 + 7
(N, K) = map(int, input().split())
dp = [[0 for _ in range(N + 1)] for _ in range(K + 1)]
for i in range(N + 1):
	dp[1][i] = 1
for k in range(2, K + 1):
	for n in range(1, N + 1):
		c = 0
		for i in range(n, N + 1, n):
			c = (c + dp[k - 1][i]) % MOD
		dp[k][n] = c % MOD
c = 0
for i in range(1, N + 1):
	c = (c + dp[K][i]) % MOD
print(c)


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

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
try:
	(sys.stdin, sys.stdout) = (open('in.txt', 'r'), open('out.txt', 'w'))
except:
	pass
ii1 = lambda : int(sys.stdin.readline().strip())
is1 = lambda : sys.stdin.readline().strip()
iia = lambda : list(map(int, sys.stdin.readline().strip().split()))
isa = lambda : sys.stdin.readline().strip().split()
mod = int(1000000000.0 + 7)
from collections import *
from math import *
from functools import lru_cache
from collections import deque as dq
(x, y) = iia()
divs = [[] for _ in range(x + 1)]
for n in range(1, x + 1):
	for k in range(n, x + 1, n):
		divs[k].append(n)
dp = [[0 for n in range(y + 1)] for k in range(x + 1)]
for n in range(1, y + 1):
	dp[1][n] = 1
for n in range(1, x + 1):
	dp[n][1] = 1
mod = int(1000000000.0 + 7)
for n in range(2, x + 1):
	for k in range(2, y + 1):
		for dv in divs[n]:
			dp[n][k] += dp[dv][k - 1]
			dp[n][k] %= mod
res = 0
for n in dp:
	res += n[-1]
	res %= mod
print(res)


import sys
inf = float('inf')
mod = 1000000007

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

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

def input():
	return sys.stdin.readline()

def main():
	(n, k) = get_ints()
	dp = [[0] * (n + 1) for _ in range(k + 1)]
	for i in range(1, n + 1):
		dp[1][i] = 1
	for i in range(1, k):
		for j in range(1, n + 1):
			for l in range(j, n + 1, j):
				dp[i + 1][l] = (dp[i + 1][l] + dp[i][j]) % mod
	ans = 0
	for i in range(1, n + 1):
		ans = (ans + dp[k][i]) % mod
	print(ans)
main()


import sys

def answer(n, k):
	dp = [[1 for j in range(n + 1)] for i in range(k + 1)]
	M = 10 ** 9 + 7
	for i in range(1, k):
		for j in range(2, n + 1):
			t = j
			while t <= n:
				dp[i + 1][t] = (dp[i + 1][t] + dp[i][j]) % M
				t += j
	return (sum(dp[k]) - 1) % M

def main():
	(n, k) = map(int, sys.stdin.readline().split())
	print(answer(n, k))
	return
main()


def main():
	mod = 1000000007
	(n, k) = map(int, input().split())
	mod = 1000000007
	(sm, l) = ([1], [1] * k)
	for _ in range(12):
		x = 0
		for (i, y) in enumerate(l):
			x += y
			l[i] = x % mod
		sm.append(l[-1])
	n += 1
	(res, sieve) = ([1] * n, [0] * n)
	for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999):
		if p >= n:
			break
		pp = p
		while pp < n:
			for i in range(pp, n, pp):
				sieve[i] += 1
			pp *= p
		for i in range(p, n, p):
			res[i] = res[i] * sm[sieve[i]] % mod
		for i in range(p, n, p):
			sieve[i] = 0
	print((sum(res) - 1) % mod)
main()


from math import sqrt, gcd, ceil, floor, log, factorial
from itertools import permutations, combinations
from collections import Counter, defaultdict
(n, k) = map(int, input().split())
mod = 10 ** 9 + 7
if n == 1:
	print(1)
else:
	d = defaultdict(list)
	for i in range(1, n // 2 + 1):
		for j in range(i + 1, n + 1):
			if j % i == 0:
				d[i].append(j)
	dp = [0] + [1 for i in range(n)]
	for i in range(k - 1):
		for i in range(1, n // 2 + 1):
			if i == 1:
				dp[i] = sum(dp) % mod
			else:
				for mul in d[i]:
					dp[i] = (dp[i] + dp[mul] % mod) % mod
	print(sum(dp) % mod)


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)


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)


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


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


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):
	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
	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)
final = 0
for num in range(2, n + 1):
	fac = factor(num)
	ans = 1
	for a in fac:
		part = ncr(fac[a] + k - 1, k - 1)
		ans = ans * part % mod
	final = (ans + final) % mod
print((final + 1) % mod)


from sys import maxsize, stdout, stdin, stderr
mod = int(1000000000.0 + 7)

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

def lint():
	return [int(x) for x in stdin.readline().split()]

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

def grid(r, c):
	return [lint() for i in range(r)]
from collections import defaultdict, Counter
import math
import heapq
from heapq import heappop, heappush
import bisect
from itertools import groupby

def gcd(a, b):
	while b:
		a %= b
		tmp = a
		a = b
		b = tmp
	return a

def lcm(a, b):
	return a / gcd(a, b) * b

def check_prime(n):
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def Bs(a, x):
	i = 0
	j = 0
	left = 0
	right = len(a)
	flag = False
	while left < right:
		mi = (left + right) // 2
		if a[mi] <= x:
			left = mi + 1
			i += 1
		else:
			right = mi
			j += 1
	if left > 0 and a[left - 1] == x:
		return (i - 1, j)
	else:
		return (-1, -1)

def nCr(n, r):
	return fact(n) / (fact(r) * fact(n - r))

def fact(n):
	res = 1
	for i in range(2, n + 1):
		res = res * i
	return res
(n, k) = lint()
dp = [[1] * (n + 1) for _ in range(k + 1)]
for i in range(1, k):
	for j in range(2, n + 1):
		tmp = j
		while tmp <= n:
			dp[i + 1][tmp] = (dp[i + 1][tmp] + dp[i][j]) % (10 ** 9 + 7)
			tmp += j
print((sum(dp[k]) - 1) % (10 ** 9 + 7))


(n, k) = map(int, input().split())
if k == 1:
	print(n)
else:
	counts = [0] * n
	m = 1000000000.0 + 7
	for i in range(1, n + 1):
		t = 1
		while (t + 1) * i <= n:
			t += 1
		counts[i - 1] = t
	for i in range(k - 2):
		temp = [0] * n
		for i in range(len(temp)):
			t = 0
			for j in range(1, 2001):
				if (i + 1) * j <= n:
					t += counts[(i + 1) * j - 1]
				else:
					break
			temp[i] = t % m
		counts = temp
	print(int(sum(counts) % m))


fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from re import *
from sys import *
from math import *
from heapq import *
from queue import *
from bisect import *
from string import *
from itertools import *
from collections import *
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from collections import Counter as cc
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def output(answer):
	stdout.write(str(answer))
(n, k) = zzz()
arr = [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:
			arr[j] += arr[t]
			arr[j] %= mod
			t += j
res = 0
for i in range(1, n + 1):
	res += arr[i] % mod
print(res % 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
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)


from sys import stdin
from collections import defaultdict
import time
K = int(1000000000.0 + 7)
(n, k) = map(int, stdin.readline().rstrip().split(' '))
lc = [0] * (n + 1)
lp = [1] * (n + 1)
lp[0] = 0
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)


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)


(N, K) = map(int, input().split())
mod = 10 ** 9 + 7
dn = [[0] * (max(N, K) + 1)] + [[1] * (max(N, K) + 1)] + [[0] * (max(N, K) + 1) for _ in range(max(N, K) + 1)]
for i in range(1, max(N, K) + 1):
	for j in range(1, N + 1):
		for k in range(j, N + 1, j):
			dn[i + 1][j] = (dn[i + 1][j] + dn[i][k]) % mod
print((sum(dn[K]) - dn[K][0]) % mod)


def mlt():
	return map(int, input().split())
(x, y) = mlt()
divs = [[] for _ in range(x + 1)]
for n in range(1, x + 1):
	for k in range(n, x + 1, n):
		divs[k].append(n)
dp = [[0 for n in range(y + 1)] for k in range(x + 1)]
for n in range(1, y + 1):
	dp[1][n] = 1
for n in range(1, x + 1):
	dp[n][1] = 1
mod = int(1000000000.0 + 7)
for n in range(2, x + 1):
	for k in range(2, y + 1):
		for dv in divs[n]:
			dp[n][k] += dp[dv][k - 1]
			dp[n][k] %= mod
res = 0
for n in dp:
	res += n[-1]
	res %= mod
print(res)


MOD = 10 ** 9 + 7
(n, k) = map(int, input().split())
dd = {}
for i in range(1, n + 1):
	dd[i] = []
	for a in range(i, n + 1, i):
		dd[i].append(a)
dp = [[0] * (n + 1) for i in range(k + 1)]
dp[1] = [0] + [1] * n
for i in range(2, k + 1):
	for a in dd:
		h = dp[i - 1][a]
		for c in dd[a]:
			dp[i][c] += h
			dp[i][c] %= MOD
print(sum(dp[-1]) % MOD)


import os
import sys
import math
from io import BytesIO, IOBase
input = sys.stdin.readline

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

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

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

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

def dijkstra(start, distance, path, n):
	visited = [False for _ in range(n)]
	distance[start] = 0
	for i in range(n):
		v = -1
		for j in range(n):
			if not visited[v] and (v == -1 or distance[j] < distance[v]):
				v = j
		if distance[v] == math.inf:
			break
		visited[v] = True
		for edge in adj[v]:
			destination = edge[0]
			weight = edge[1]
			if distance[v] + weight < distance[destination]:
				distance[destination] = distance[v] + weight
				path[destination] = v

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def npr(n, r):
	return math.factorial(n) // math.factorial(n - r)

def seive(n):
	primes = [True] * (n + 1)
	ans = []
	for i in range(2, n):
		if not primes[i]:
			continue
		j = 2 * i
		while j <= n:
			primes[j] = False
			j += i
	for p in range(2, n + 1):
		if primes[p]:
			ans += [p]
	return ans

def factors(n):
	factors = []
	x = 1
	while x * x <= n:
		if n % x == 0:
			if n // x == x:
				factors.append(x)
			else:
				factors.append(x)
				factors.append(n // x)
		x += 1
	return factors

def main():
	try:
		(n, k) = invr()
		dp = [1] * n
		ans = n
		for i in range(k - 1):
			for j in range(2, n + 1):
				temp = dp[j - 1]
				for k in range(j * 2, n + 1, j):
					temp += dp[k - 1]
				ans += temp
				ans %= 10 ** 9 + 7
				dp[j - 1] = temp
				dp[j - 1] %= 10 ** 9 + 7
		print(ans % (10 ** 9 + 7))
	except Exception as e:
		print(e)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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


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


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


(n, k) = map(int, input().split())
d = 1000000007
n += 1
r = [{} for i in range(n)]
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
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)


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


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


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)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass

def pmat(A):
	for ele in A:
		print(*ele, end='\n')
(n, k) = L()
dp = [[0 for i in range(k)] for j in range(n + 1)]
for i in range(n + 1):
	dp[i][0] = 1
for i in range(k - 1):
	for j in range(1, n + 1):
		for m in range(j, n + 1, j):
			dp[m][i + 1] = (dp[j][i] + dp[m][i + 1]) % mod
print(sum((dp[i][-1] for i in range(1, n + 1))) % mod)
endtime = time.time()


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


from sys import stdin, stdout

def main():
	(n, k) = [int(x) for x in stdin.readline().rstrip().split()]
	table = [[0] * (n + 1) for _ in range(k + 1)]
	table[1][1:] = [1] * n
	MOD = int(1000000000.0 + 7)
	for i in range(2, k + 1):
		for j in range(1, n + 1):
			for k in range(j, n + 1, j):
				table[i][k] += table[i - 1][j]
				table[i][k] %= MOD
	print(sum(table[-1]) % MOD)
main()


import os, sys
from io import BytesIO, IOBase

def main():
	mod = 10 ** 9 + 7
	(k, n) = map(int, input().split())
	dp = [[0] * (k + 1) for _ in range(n)]
	dp[0] = [0] + [1] * k
	for i in range(1, n):
		for j in range(1, k + 1):
			for x in range(j, k + 1, j):
				dp[i][j] = (dp[i][j] + dp[i - 1][x]) % mod
	x = 0
	for i in dp[-1]:
		x = (x + i) % mod
	print(x)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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


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


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
MOD = 10 ** 9 + 7
(n, k) = map(int, input().split())
dd = {}
for i in range(2, n + 1):
	dd[i] = []
	for a in range(i, n + 1, i):
		dd[i].append(a)
dp = [[1 for _ in range(n + 1)] for i in range(k + 1)]
for i in range(2, k + 1):
	for a in range(2, n + 1):
		h = dp[i - 1][a] % MOD
		for c in dd[a]:
			dp[i][c] += h
			dp[i][c] %= MOD
print((sum(dp[-1]) - 1) % MOD)


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(sum(dp[-1]) % mod)


(n, k) = map(int, input().split())
mod = 10 ** 9 + 7
dp = []
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)


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


from sys import stdin, stdout
from math import gcd
input = stdin.readline

def main():
	t = 1
	for i in range(t):
		(n, k) = map(int, input().split())
		mod = 10 ** 9 + 7
		n2 = n + 1
		ar = [[0] * n2 for i in range(k)]
		for i in range(n + 1):
			ar[0][i] = 1
		ar[0][0] = 0
		for i in range(k - 1):
			for z in range(1, n2):
				for j in range(z, n2, z):
					ar[i + 1][j] += ar[i][z]
					ar[i + 1][j] %= mod
		print(sum(ar[-1]) % mod)
main()


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)
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]:
				tmp = (tmp + dp[l - 1][j - 1]) % mod
			dp[i].append(tmp)
good = 0
for i in dp:
	good = (good + i[-1]) % mod
print(good)


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)


import os.path
from math import gcd, floor, ceil
from collections import *
import sys
mod = 1000000007
INF = float('inf')

def st():
	return list(sys.stdin.readline().strip())

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

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

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

def pr(n):
	return sys.stdout.write(str(n) + '\n')

def prl(n):
	return sys.stdout.write(str(n) + ' ')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	(n, k) = mp()
	dp = [[0] * (k + 1) for i in range(n + 1)]
	for i in range(n + 1):
		dp[i][1] = 1
	for j in range(1, k):
		for i in range(1, n + 1):
			x = 1
			while x * i <= n:
				dp[x * i][j + 1] += dp[i][j]
				dp[x * i][j + 1] %= mod
				x += 1
	ans = 0
	for i in range(1, n + 1):
		ans += dp[i][k]
		ans %= mod
	pr(ans)
for _ in range(1):
	solve()


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))
ilelec = lambda : map(int1, input().split())
alelec = lambda : list(map(int1, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
(n, k) = ilele()
dp = list2d(k + 1, n + 1, 0)
for i in range(n + 1):
	dp[0][i] = 1
for i in range(1, k + 1):
	for l in range(1, n + 1):
		for j in range(l, n + 1, l):
			dp[i][l] += dp[i - 1][j]
			dp[i][l] %= MOD
print(dp[k][1])


import sys
import os
from math import sqrt, gcd, ceil, log, floor, sin, pi
from math import factorial as fact
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
from itertools import permutations
input = sys.stdin.readline

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

def read_f():
	return list(map(float, input().strip().split()))
MOD = 10 ** 9 + 7

def main():
	(n, k) = read()
	dp1 = [0] * (n + 1)
	dp2 = [0] * (n + 1)
	for i in range(1, n + 1):
		dp1[i] = 1
	y = 0
	for i in range(k - 1, 0, -1):
		for j in range(1, n + 1):
			for x in range(j, n + 1, j):
				if y:
					dp1[j] += dp2[x]
					dp1[j] %= MOD
				else:
					dp2[j] += dp1[x]
					dp2[j] %= MOD
		if y:
			dp2 = [0] * (n + 1)
		else:
			dp1 = [0] * (n + 1)
		y = (y + 1) % 2
	if not y:
		print(sum(dp1) % MOD)
	else:
		print(sum(dp2) % MOD)
main()


(n, k) = map(int, input().rstrip().split(' '))
l = [n // i for i in range(1, n + 1)]
mod = 1000000007
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]) % mod
	print(sum(l) % mod)


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


MOD = 1000000007
(n, k) = tuple(map(int, input().split()))
dp = [[1 if j == 1 else 0 for j in range(k + 1)] for i 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] + dp[i][j]) % MOD
ans = sum([dp[i][k] for i in range(1, n + 1)]) % MOD
print(ans)


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)


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


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

def getd():
	l = []
	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 n // i == i:
					l1.append(i)
				else:
					l1.append(i)
					l1.append(n // i)
			i = i + 1
		l.append(l1)
	return l
l = getd()
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
	print(suma % mod)


import random
import math
from collections import defaultdict
import itertools
from sys import stdin, stdout
import sys
import operator

def main():
	mod = 10 ** 9 + 7
	(n, k) = list(map(int, input().split()))
	dp = [[0 for _ in range(k - 1)] for _ in range(n)]
	ans = 0
	if k == 1:
		print(n)
	else:
		for j in range(n):
			dp[j][k - 2] = n // (j + 1)
		for i in range(k - 3, -1, -1):
			for j in range(n):
				m = 1
				while (j + 1) * m <= n:
					dp[j][i] = (dp[j][i] + dp[(j + 1) * m - 1][i + 1]) % mod
					m += 1
		ans = 0
		for i in range(n):
			ans = (ans + dp[i][0]) % mod
		print(ans)
main()