#include"bits/stdc++.h"
using namespace std;
#define LL long long
#define PB push_back
#define MP make_pair

#define MOD 1000000007

LL N, K;
LL dp[102][32000];
LL sum[102][32000],keisu[102][32000];
int main(){
	cin >> N >> K;
	for(int i=K+1; i>=0; i--){
		sum[i][0] = 0;
		keisu[i][0] = 0;
		for(int j=1; j<=sqrt(N); j++){
			if(i >= K){
				dp[i][j] = 1;
			}
			else{
				dp[i][j] = 0;
				dp[i][j] += sum[i+1][min((LL)sqrt(N),N/j)];
				if(j*(LL)sqrt(N) <= N){
					if(i == K-1){
						dp[i][j] += dp[i+2][1] * max(0LL, N/j-(LL)sqrt(N));
					}
					else{
						dp[i][j] += sum[i+2][j]*max(0LL, N/j-(LL)sqrt(N));
						dp[i][j] += keisu[i+2][(LL)sqrt(N)]-keisu[i+2][j];
					}
				}
				dp[i][j] += 2*MOD;
				dp[i][j] %= MOD;
			}

			sum[i][j] = (dp[i][j] + sum[i][j-1]) % MOD;
			keisu[i][j] = (dp[i][j]*max(0LL,(N/j-(LL)sqrt(N))) + keisu[i][j-1]) % MOD;
		}
	}
	cout << dp[0][1] << endl;
}

### Prompt

Please provide a CPP coded solution to the problem described below:

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"bits/stdc++.h"
using namespace std;
#define LL long long
#define PB push_back
#define MP make_pair

#define MOD 1000000007

LL N, K;
LL dp[102][32000];
LL sum[102][32000],keisu[102][32000];
int main(){
	cin >> N >> K;
	for(int i=K+1; i>=0; i--){
		sum[i][0] = 0;
		keisu[i][0] = 0;
		for(int j=1; j<=sqrt(N); j++){
			if(i >= K){
				dp[i][j] = 1;
			}
			else{
				dp[i][j] = 0;
				dp[i][j] += sum[i+1][min((LL)sqrt(N),N/j)];
				if(j*(LL)sqrt(N) <= N){
					if(i == K-1){
						dp[i][j] += dp[i+2][1] * max(0LL, N/j-(LL)sqrt(N));
					}
					else{
						dp[i][j] += sum[i+2][j]*max(0LL, N/j-(LL)sqrt(N));
						dp[i][j] += keisu[i+2][(LL)sqrt(N)]-keisu[i+2][j];
					}
				}
				dp[i][j] += 2*MOD;
				dp[i][j] %= MOD;
			}

			sum[i][j] = (dp[i][j] + sum[i][j-1]) % MOD;
			keisu[i][j] = (dp[i][j]*max(0LL,(N/j-(LL)sqrt(N))) + keisu[i][j-1]) % MOD;
		}
	}
	cout << dp[0][1] << endl;
}

```