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.BufferedReader;
            import java.io.BufferedWriter;
            import java.io.IOException;
            import java.io.InputStream;
            import java.io.InputStreamReader;
            import java.io.OutputStream;
            import java.io.OutputStreamWriter;
            import java.io.PrintWriter;
            import java.io.Writer;
            import java.util.ArrayList;
            import java.util.Arrays;
            import java.util.Collections;
            import java.util.Comparator;
            import java.util.HashMap;
            import java.util.LinkedList;
            import java.util.List;
            import java.util.Map;
            import java.util.StringTokenizer;


            import java.io.BufferedReader;
            import java.io.BufferedWriter;
            import java.io.IOException;
            import java.io.InputStream;
            import java.io.InputStreamReader;
            import java.io.OutputStream;
            import java.io.OutputStreamWriter;
            import java.io.PrintWriter;
            import java.io.Writer;
            import java.util.ArrayList;
            import java.util.Arrays;
            import java.util.Collections;
            import java.util.Comparator;
            import java.util.HashMap;
            import java.util.LinkedList;
            import java.util.List;
            import java.util.Map;
            import java.util.StringTokenizer;


            public class Main {

                public static void main(String[] args) {
                    InputStream inputStream = System.in;
                    OutputStream outputStream = System.out;
                    InputReader  in = new InputReader (inputStream);
                    PrintWriter out = new PrintWriter(outputStream);
                    new Main().solve(in, out);
                    out.close();
                    System.exit(0);
                }

                /*
                    begin()
                */
                
                class Pair implements Comparable<Pair>{
                    int l,r,id;
                    
                    Pair(int l, int r, int id){
                        this.l = l;
                        this.r = r;
                        this.id = id;
                    }
                    
                    @Override
                    public int compareTo(Pair o) {
                        if(this.l == o.l) return this.id - o.id;
                        return this.l - o.l;
                    }
                }
                
                
                void solve(InputReader in, PrintWriter out){
                    final long MOD = (long)1e9+7;
                    final int MAX = 2000;
                    int n = in.nextInt();
                    int k = in.nextInt();
                    long dp[][] = new long[k+1][n+1];
                    Arrays.fill(dp[1], 1);
                    
                    List<Integer> factors[] = new ArrayList[MAX+1];
                    for(int i=0; i<=MAX; i++){
                        factors[i] = new ArrayList<Integer>();
                    }
                    
                    for(int i=1; i<=MAX; i++){
                        for(int j=i; j<=MAX; j+=i){
                            factors[j].add(i);
                        }
                    }
                    
                    for(int i=2; i<=k; i++){
                        for(int j=1; j<=n; j++){
                            for(int s=0; s<factors[j].size(); s++){
                                dp[i][j] = (dp[i][j] + dp[i-1][factors[j].get(s)])%MOD;
                            }
                        }
                    }
                    
                    long ans = 0;
                    for(int i=1; i<=n; i++){
                        ans = (ans+dp[k][i])%MOD;
                    }
                    out.println(ans);
                }

                /*
                    end();
                */
                static class InputReader {
                    public BufferedReader reader;
                    public StringTokenizer tokenizer;
                    public InputReader(InputStream stream) {
                        reader = new BufferedReader(new InputStreamReader(stream), 32768);
                        tokenizer = null;
                    }

                    public String next() {
                        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                            try {
                                tokenizer = new StringTokenizer(reader.readLine());
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        return tokenizer.nextToken();
                    }

                    public int nextInt(){
                        return Integer.parseInt(next());
                    }

                    public long nextLong() {
                        return Long.parseLong(next());
                    }

                    public double nextDouble() {
                        return Double.parseDouble(next());
                    }

                    public String nextLine() {
                        String str = "";
                        try {
                            str = reader.readLine();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return str;
                    }
                }
            }