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:
/**
 * 
 */


 // @author Winry Rockbell
 import java.util.Scanner;
 
public class HelloWorld {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	int n,k;
	long mod=1000000007;
	Scanner in = new Scanner(System.in);
	n=in.nextInt();
	k=in.nextInt();
	int numArray[][]=new int[2001][100];
	int [] num = new int[2001];
	num[2]=1;
	numArray[2][0]=1;
	numArray[2][1]=2;
	for(int ki=3;ki<=n;ki++)
	{int val=ki;
	
    
    int index = 0;

    for (int i = 1; i<=(ki/2+1); i++) 
	{
        if (val % i == 0) 
		{
            numArray[ki][index++] = i;
            
        }
        
    }
    num[ki]=index;
    numArray[ki][index] = val;
    
	}
	long dp[][]=new long[2001][2001];
   for(int i=1;i<=k;i++)
   {
	   for(int j=1;j<=n;j++)
	   {dp[i][j]=0;
		   if(j==1)
			   dp[i][j]=1;
		   else if(i==1)
		   {
			   dp[i][j]=j;
		   }
		   else
		   {
 dp[i][j]=(dp[i][j]+dp[i][j-1]+1)%mod;
			   
			   
			   for(int mo=1;mo<=num[j];mo++)
			   { //if(i==2&&j==2)
			   //cout<<mo<<" "<<numArray[j][mo]<<endl;
				   dp[i][j]=(dp[i][j]+((dp[i-1][numArray[j][mo]]-dp[i-1][numArray[j][mo]-1])%mod))%mod;
			   }
		   }
		   if(dp[i][j]<0)
			   dp[i][j]=dp[i][j]+mod;
	   }
	   
   }
   System.out.println(dp[k][n]);
	}
	/*static int[] factorsOf(int val) {
        int limit = (int) Math.ceil(Math.sqrt(val));
        int [] numArray = new int[limit];
        int index = 0;

        for (int i = 1; i <= limit; i++) {
            if (val % i == 0) {
                numArray[index++] = i;
                val /= i;
            }
        }
        numArray[index] = val;
        return numArray;
    }*/
}