#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

const int MAXD = 1e5, MAXK = 105, MOD = 1e9 + 7;
vector<int> d;
void addb(int a) {
	int m = a;
	d.push_back(1);
	while (m && m != 1) {
		int t = a / m, nxm = a / (t + 1);
		d.push_back(nxm + 1);
		d.push_back(t);
		m = nxm;
	}
	sort(d.begin(), d.end());
	d.resize(unique(d.begin(), d.end()) - d.begin());
	d.push_back(a + 1);
}
long long dp[MAXD], dpo[MAXD];
int n, k;

int main() {
	cin >> n >> k;
	addb(n);
	dpo[0] = d[1] - d[0];
	for (int i = 1; i < d.size() - 1; i++)
		dpo[i] = d[i + 1] - d[i] + dpo[i - 1];
	for (int i = 1; i < k; i++) {
		for (int j = 0; j < d.size() - 1; j++) {
			int ind = upper_bound(d.begin(), d.end(), n / d[j]) - d.begin();
			dp[j] = dpo[ind - 1] * (d[j + 1] - d[j]) % MOD;
		}
		swap(dp, dpo);
		for (int i = 1; i < d.size() - 1; i++)
			dpo[i] += dpo[i - 1], dpo[i] %= MOD;
	}
	cout << dpo[d.size() - 2];
}
### Prompt

Please formulate a CPP solution to the following problem:

Find the number of sequences of length K consisting of positive integers such that the product of any two adjacent elements is at most N, modulo 10^9+7.

Constraints

* 1\leq N\leq 10^9
* ~~1~~ 2\leq K\leq 100 (fixed at 21:33 JST)
* N and K are integers.

Input

Input is given from Standard Input in the following format:


N K


Output

Print the number of sequences, modulo 10^9+7.

Examples

Input

3 2


Output

5


Input

10 3


Output

147


Input

314159265 35


Output

457397712

### Response

```cpp
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

const int MAXD = 1e5, MAXK = 105, MOD = 1e9 + 7;
vector<int> d;
void addb(int a) {
	int m = a;
	d.push_back(1);
	while (m && m != 1) {
		int t = a / m, nxm = a / (t + 1);
		d.push_back(nxm + 1);
		d.push_back(t);
		m = nxm;
	}
	sort(d.begin(), d.end());
	d.resize(unique(d.begin(), d.end()) - d.begin());
	d.push_back(a + 1);
}
long long dp[MAXD], dpo[MAXD];
int n, k;

int main() {
	cin >> n >> k;
	addb(n);
	dpo[0] = d[1] - d[0];
	for (int i = 1; i < d.size() - 1; i++)
		dpo[i] = d[i + 1] - d[i] + dpo[i - 1];
	for (int i = 1; i < k; i++) {
		for (int j = 0; j < d.size() - 1; j++) {
			int ind = upper_bound(d.begin(), d.end(), n / d[j]) - d.begin();
			dp[j] = dpo[ind - 1] * (d[j + 1] - d[j]) % MOD;
		}
		swap(dp, dpo);
		for (int i = 1; i < d.size() - 1; i++)
			dpo[i] += dpo[i - 1], dpo[i] %= MOD;
	}
	cout << dpo[d.size() - 2];
}
```