#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const ll MOD = 1e9 + 7;
ll N, K;
ll M;
vector<ll> Mult;
vector<vector<ll>> Dp;

void init() {
  set<ll> s_values;
  for (ll i = 1; i * i <= N; ++i) {
    s_values.insert(i);
    s_values.insert(N / i);
  }
  vector<ll> values;
  for (ll v : s_values) values.push_back(v);
  M = values.size();
  Mult.resize(M);
  for (ll i = 0; i < M; ++i) Mult[i] = values[i] - (i == 0 ? 0 : values[i - 1]);
}
int main() {
  cin >> N >> K;
  init();
  Dp.resize(K + 1);
  for (auto &dp : Dp) dp.resize(M);
  fill(Dp[0].begin(), Dp[0].end(), 1);
  for (ll k = 0; k < K; ++k) {
    for (ll i = 0; i < M; ++i) {
      Dp[k + 1][i] = Mult[i] * Dp[k][M - 1 - i] % MOD;
      if (i > 0) (Dp[k + 1][i] += Dp[k + 1][i - 1]) %= MOD;
    }
  }
  cout << Dp[K][M - 1] << endl;
  return 0;
}

### Prompt

Please create a solution in Cpp 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 <bits/stdc++.h>
using namespace std;

typedef long long ll;

const ll MOD = 1e9 + 7;
ll N, K;
ll M;
vector<ll> Mult;
vector<vector<ll>> Dp;

void init() {
  set<ll> s_values;
  for (ll i = 1; i * i <= N; ++i) {
    s_values.insert(i);
    s_values.insert(N / i);
  }
  vector<ll> values;
  for (ll v : s_values) values.push_back(v);
  M = values.size();
  Mult.resize(M);
  for (ll i = 0; i < M; ++i) Mult[i] = values[i] - (i == 0 ? 0 : values[i - 1]);
}
int main() {
  cin >> N >> K;
  init();
  Dp.resize(K + 1);
  for (auto &dp : Dp) dp.resize(M);
  fill(Dp[0].begin(), Dp[0].end(), 1);
  for (ll k = 0; k < K; ++k) {
    for (ll i = 0; i < M; ++i) {
      Dp[k + 1][i] = Mult[i] * Dp[k][M - 1 - i] % MOD;
      if (i > 0) (Dp[k + 1][i] += Dp[k + 1][i - 1]) %= MOD;
    }
  }
  cout << Dp[K][M - 1] << endl;
  return 0;
}

```