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 DAY1 {
		
	public static void main(String[] args) throws IOException {
		new DAY1().solve();
	}
	
	PrintWriter out;
	int n;
	int m;
	boolean[] use;
	int mod = 1000000007;
	int rv = 0;
	ArrayList<Integer>[] g;
	int[] res;
	int[] a; 
	int p, q;
	
	long[][] dp = new long[2010][2010];
	
	HashMap<Long, Long> map = new HashMap();
	void solve() throws IOException{
		Reader in = new Reader("a.in");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
		//out = new PrintWriter(new FileWriter(new File("a.out"))); 
		 
		n = in.nextInt();
		m = in.nextInt();
		
		long res = 0;
		
		for (int i = 1; i <= n; i++ )
			res += (f(0, i)%mod);
		
		out.print(res%mod);
		out.flush();
		out.close();
		
	}
	
	long f(int i, int k) {
		
		if (i == m-1)
			return 1;
		
		long res = 0;
		
		if (dp[i][k] != 0)
			return dp[i][k];
		
		for (int j = k; j <= n; j+=k) {
			res += (f(i+1, j)%mod);
		}
		
		dp[i][k] = res;
		return res;
		
	}
	
	class SegmentTree {
		
		int[][] tree = new int[26][4000000];
		
		void buld(int v, int tl, int tr, int i, String s) {
			if (tl == tr)
				tree[i][v] = s.charAt(0);
			
			
		}
		
		void update() {
			
		}
		
		int query() {
			
			return 0;
		}
		
	}
	
	long pow(int x, int m) {
		if (m == 0)
			return 1;
		return x*pow(x, m-1);
	}
	
class Pair implements Comparable<Pair> {
		
		int a;
		int b;
		
		Pair (int a, int b) {
			this.a = a;
			this.b = b;
		}

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

	class Item implements Comparable<Item> {

		int a;
		int b;
		long u;
		
		Item(int v, int l, long z) {
			this.a = v;
			this.b = l;
			this.u = z;
		}
		
		@Override
		public int compareTo(Item item) {
			
			if (u > item.u)
				return 1;
			else
			if (u < item.u)
				return -1;
			else {
				return 0;
			}
						
		}
		
	}
	
	class Reader {
	    
	    StringTokenizer token;
	    BufferedReader in;
	    
	    public Reader(String file) throws IOException {
	       //in = new BufferedReader( new FileReader( file ) );
	       in = new BufferedReader( new InputStreamReader( System.in ) );
	    }
	    
	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }
	    
	    public int nextInt() throws IOException {
	        return Integer.parseInt(Next());
	    }
	    
	    public long nextLong() throws IOException {
	        return Long.parseLong(Next());
	    }
	    
	    public String nextString() throws IOException {
	        return in.readLine();
	    }
	    
	    public String Next() throws IOException {
	        while (token == null || !token.hasMoreTokens()) {
	            token = new StringTokenizer(in.readLine());
	        }
	        return token.nextToken();
	    }

	    
	}
	
}