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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

/**
 *
 */
public class TaskB {
    public static void main(String[] args) {
        InputStream inputStream;
        String str = null;
        if(str == null){
            inputStream = System.in;
        }else{
            inputStream = new ByteArrayInputStream(str.getBytes());
        }
        
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(1, in, out);
        out.close();
    }
    

    static class Solver {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int maxInt = in.nextInt();
            int length = in.nextInt();
            HashMap<Integer, HashSet<Integer>> divisors = new HashMap<>();
            long[][]results = new long[length+1][maxInt+1];
            
            
            for(int i=1;i<=maxInt;i++){
                divisors.put(i, new HashSet<>());
                for(int j=1;j<=i;j++){
                    if(i%j==0){
                        divisors.get(i).add(j);
                    }
                }
                
            }
            
            
            for(int i=1;i<=maxInt;i++){
                results[1][i] = 1;
            }
            
            for(int l=2;l<=length;l++){
                for(int c = 1;c<= maxInt;c++){
                    for(int j=c;j<=maxInt;j+=c){
                        results[l][j] += results[l-1][c];
                        results[l][j] %= 1000000007;
                    }
                   // for(int d : divisors.get(c)){
                    //    results[l][c] += results[l-1][d];
                    //    results[l][c] %= 1000000007;
                   // }
                    //results[l][c]++;
                }
            }
            
            /*for(int i=0;i<= length;i++){
                for(int j=0;j<=maxInt;j++){
                    System.out.print(results[i][j]+" ");
                }System.out.println();
            }*/
            
            long result = 0;
            
            for(int i=0;i<=maxInt;i++){
                result += results[length][i] ;
                result %= 1000000007;
            }
            
            System.out.println(result);
        }
    }
    
    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());
        }
        
    }
}