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:
// package name;
import java.io.*;
import java.util.*;

public class M {

	static long longmx = 9223372036854775807l;
	static long longmn = -9223372036854775808l;
	static int intmx = 2147483647;
	static int intmn = -2147483648;
	static Scanner s = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static long mod = 1000000007;
	public static void main(String[] args) {
		int t = 1;
		//t = s.nextInt();
		StringBuffer sb = new StringBuffer();
		while (t > 0) {
			t--;
			int n = iinp();
			int k = iinp();
			//double ans = m, sum = 0;
			long dp[][] = new long[n + 1][k + 1];
			for(int i = 0; i < n + 1; i++) Arrays.fill(dp[i], -1); 
			long ans = fun(1, 0, k, n, dp);
			sb.append(ans);
		}
		out.print(sb);
		out.flush();
	}

	private static long fun(int p, int id, int k, int n, long dp[][]) {
		if(id == k) return 1;
		long ans = 0;
		if(dp[p][id] != -1) return dp[p][id];
		for(int i = p; i <= n; i += p) {
			ans = ans + fun(i, id + 1, k, n, dp);
			if(ans >= 1000000007) ans -= 1000000007; 
		}
		return dp[p][id] = ans;
	}

	static int iinp() {
		return s.nextInt();
	}

	static long linp() {
		return s.nextLong();
	}

	static double dinp() {
		return s.nextDouble();
	}

	static String sinp() {
		return s.next();
	}

	static String slinp() {
		return s.nextLine();
	}

	static int[] idecarr(int n) {
		return new int[n];
	}

	static long[] ldecarr(int n) {
		return new long[n];
	}

	static String[] sdecarr(int n) {
		return new String[n];
	}

	static int[][] idec2darr(int n, int m) {
		return new int[n][m];
	}

	static long[][] ldec2darr(int n, int m) {
		return new long[n][m];
	}

	static int[] iinparr(int n, int st) {
		int a[] = idecarr(n);
		for (int i = st; i < st + n; i++) {
			a[i] = iinp();
		}
		return a;
	}

	static long[] linparr(int n, int st) {
		long a[] = ldecarr(n);
		for (int i = st; i < st + n; i++) {
			a[i] = linp();
		}
		return a;
	}

	static int[][] iinp2darr(int n, int m) {
		int a[][] = idec2darr(n, m);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				a[i][j] = iinp();
			}
		}
		return a;
	}

	static long[][] linp2darr(int n, int m) {
		long a[][] = ldec2darr(n, m);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				a[i][j] = iinp();
			}
		}
		return a;
	}

	static long min(long... a) {
		long min = longmx;//Long.MAX_VALUE;
		for (long i : a) {
			if (i < min)
				min = i;
		}
		return min;
	}

	static long max(long... a) {
		long max = longmn;//Long.MIN_VALUE;
		for (long i : a) {
			if (i > max)
				max = i;
		}
		return max;
	}

	static long gcd(long a, long b) {
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static void sort(int a[]) {
		Arrays.sort(a);
	};

	static void sort(int a[], int st, int e) {
		Arrays.sort(a, st, e);
	};

	static void sort(long a[]) {
		Arrays.sort(a);
	};

	static void sort(long a[], int st, int e) {
		Arrays.sort(a, st, e);
	};

	static void sort(String a[]) {
		Arrays.sort(a);
	};

	static void sort(String a[], int st, int e) {
		Arrays.sort(a, st, e);
	};

	static StringBuffer printarr(long a[]) {
		StringBuffer ans = new StringBuffer();
		for (long i : a)
			ans.append(i + " ");
		ans.append("\n");
		return ans;
	}

	static StringBuffer printarr(int a[]) {
		StringBuffer ans = new StringBuffer();
		for (int i : a)
			ans.append(i + " ");
		ans.append("\n");
		return ans;
	}

}

class Pair {
	long a, b;

	Pair(long x, long y) {
		a = x;
		b = y;
	}
}

/*
 * to sort the array of pair
 * Compare obj = new Compare();
 * obj.compare(arr);
 */
class Compare {

	static void compare(Pair arr[]) {
		Arrays.sort(arr, new Comparator<Pair>() {
			@Override
			public int compare(Pair p1, Pair p2) {
				if (p1.a != p2.a)
					return (p1.a - p2.a > 0) ? 1 : -1;
				else
					return (p1.b - p2.b > 0) ? 1 : -1;
			}
		});
	}
}