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.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class MashmokhAndACM 
{
	private static int n,k,mod = 1000000007;
	private static int memo[][];
	public static void main(String[] args) 
	{
		BufferedTokenizer io = new BufferedTokenizer(System.in);
		n = io.nextInt();
		k = io.nextInt();
		memo = new int[n+1][k+1];
		for (int i = 0; i < n+1; i++) Arrays.fill(memo[i], -1);
		io.println(solve(1,0)%mod+"" ); 
	}
	
	private static int solve(int prev,int length) 
	{
		if(length==k) 	return memo[prev][length] = 1;
		else if(length>k) return memo[prev][length] = 0;
		else if(memo[prev][length]!=-1) return memo[prev][length];
		
		int result = 0;
		for (int i = prev; i <= n; i+=prev) 
		{
			result = (result%mod + solve(i,length+1)%mod)%mod;
		}
		
		return memo[prev][length] = result;
	}

	public static class BufferedTokenizer 
	 {
	        private BufferedReader reader;
	        private StringTokenizer tokenizer;
	        private PrintWriter writer;
	 
	        public BufferedTokenizer(InputStream stream) 
	        {
	            reader = new BufferedReader(new InputStreamReader(stream));
	            writer = new PrintWriter(System.out);
	            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 void println(String x)
	        {
	        	writer.println(x);
	        	writer.flush();
	        }
	    }
}