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].

Difficulty: MEDIUM

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)


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


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)


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


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)


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


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)


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


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