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

Solution (in PYTHON):

Solution:
import math

MOD = 10**9 + 7

def count_good_sequences(n, k):
    
    if k == 1: return n
    
    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)