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

Solution:
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class CF {

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer tok;

    public static void main(String[] args) throws IOException {
        try {
            in = new BufferedReader(new FileReader("1a.in"));
            out = new PrintWriter(new File("1a.out"));
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
        }
        tok = new StringTokenizer("");
        new CF().solve();
        out.flush();
        out.close();
    }

    String nextTok() throws IOException {
        if (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextTok());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextTok());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextTok());
    }

    static class Pair implements Comparable<Pair>  {
        int x;
        int y;

        Pair (int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Pair o) {
            if (x < o.x) return -1;
            if (x > o.x) return 1;
            return 0;
        }
    }

    int nums;
    int len;
    int MOD = 1000000007;
    int d[][] = new int[2010][2010];

    int f(int l, int num) {
        if (l == len) return 1;
        if (d[l][num] != 0) return d[l][num];
        int ans = 0;
        for (int i = num; i <= nums; i+=num) {
            ans += (f(l+1,i)%MOD);
            ans = ans%MOD;
        }
        d[l][num] = ans%MOD;
        return ans%MOD;
    }


    void solve() throws IOException {
        nums = nextInt();
        len = nextInt();
        int ans = 0;
        for (int i = 1; i <= nums; i++) {
            ans += (f(1,i)%MOD);
            ans %= MOD;
            //d[1][i] = ans%MOD;
        }
        System.out.println(ans);
//        System.out.println(d[1][nums]);

    }

    private BigInteger catalan (int i) {
        return factorial(2 * i).divide((factorial(i + 1).multiply(factorial(i))));
    }

    private BigInteger factorial (int i) {
        BigInteger n = BigInteger.valueOf(i);
        if (i == 0) {
            return new BigInteger("1");
        }
        while (--i > 0) {
            n = n.multiply(BigInteger.valueOf(i));
        }
        return n;
    }
}