#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;
using ll = long long;
using pii = pair<int, int>;

constexpr ll mod = 1e9 + 7;
int n, k;
vector<int> s, inv;
int main() {
	scanf("%d %d", &n, &k);
	int rt = 1;
	for (; rt * rt <= n; rt++)
		s.emplace_back(rt);
	for (rt--; 1 <= rt; rt--)
		s.emplace_back(n / rt);
	vector<ll> dp(s.size()+1, 1);
	for (int j = 1; j < k; j++) {
		vector<ll> dp2(s.size()+1, 0);
		for (int i = 0; i < s.size(); i++) {
			dp2[0] += (0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
			dp2[s.size() - i] = -(0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
		}
		for (int i = 1; i < s.size(); i++)
			dp2[i] = (dp2[i - 1] + dp2[i]) % mod;
		dp.swap(dp2);
	}
	ll count = 0;
	for (int i = 0; i < s.size(); i++) {
		count += (0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
		count %= mod;
	}
	if (count < 0)
		count += mod;
	printf("%lld\n", count);
}
### Prompt

Construct a CPP code solution to the problem outlined:

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 <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;
using ll = long long;
using pii = pair<int, int>;

constexpr ll mod = 1e9 + 7;
int n, k;
vector<int> s, inv;
int main() {
	scanf("%d %d", &n, &k);
	int rt = 1;
	for (; rt * rt <= n; rt++)
		s.emplace_back(rt);
	for (rt--; 1 <= rt; rt--)
		s.emplace_back(n / rt);
	vector<ll> dp(s.size()+1, 1);
	for (int j = 1; j < k; j++) {
		vector<ll> dp2(s.size()+1, 0);
		for (int i = 0; i < s.size(); i++) {
			dp2[0] += (0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
			dp2[s.size() - i] = -(0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
		}
		for (int i = 1; i < s.size(); i++)
			dp2[i] = (dp2[i - 1] + dp2[i]) % mod;
		dp.swap(dp2);
	}
	ll count = 0;
	for (int i = 0; i < s.size(); i++) {
		count += (0 < i ? s[i] - s[i - 1] : s[i]) * dp[i] % mod;
		count %= mod;
	}
	if (count < 0)
		count += mod;
	printf("%lld\n", count);
}
```