#include <bits/stdc++.h>
using namespace std;
const int BASE = 1e9 + 7;
const int LIM = 31622;

long long f[111][LIM + 5], g[111][LIM + 5];

int main()
{
  int n, k, m = 1;
  cin >> n >> k;
  while ((m + 1) * (m + 1) <= n)
    m++;

  for (int j = 1; j <= m; j++)
  {
    f[0][j] = 1;
    g[0][j] = n;
    f[1][j] = j;
    g[1][j] = (g[1][j - 1] + n / j) % BASE;
  }

  for (int i = 2; i <= k + 1; i++)
    for (int j = 1; j <= m; j++)
    {
      long long curF = (f[i - 1][m] + f[i - 2][j] * (n / j - m)) % BASE;
      long long difG = (g[i - 2][m] - g[i - 2][j] + BASE) % BASE;
      long long difF = (f[i - 2][m] - f[i - 2][j] + BASE) % BASE;
      long long toAdd = (difG - difF * m % BASE + BASE) % BASE;
      curF = (curF + toAdd) % BASE;
      g[i][j] = (g[i][j - 1] + curF * (n / j)) % BASE;
      f[i][j] = (f[i][j - 1] + curF) % BASE;
    }

  cout << f[k + 1][1] << endl;
}

### Prompt

Develop a solution in Cpp 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;
const int BASE = 1e9 + 7;
const int LIM = 31622;

long long f[111][LIM + 5], g[111][LIM + 5];

int main()
{
  int n, k, m = 1;
  cin >> n >> k;
  while ((m + 1) * (m + 1) <= n)
    m++;

  for (int j = 1; j <= m; j++)
  {
    f[0][j] = 1;
    g[0][j] = n;
    f[1][j] = j;
    g[1][j] = (g[1][j - 1] + n / j) % BASE;
  }

  for (int i = 2; i <= k + 1; i++)
    for (int j = 1; j <= m; j++)
    {
      long long curF = (f[i - 1][m] + f[i - 2][j] * (n / j - m)) % BASE;
      long long difG = (g[i - 2][m] - g[i - 2][j] + BASE) % BASE;
      long long difF = (f[i - 2][m] - f[i - 2][j] + BASE) % BASE;
      long long toAdd = (difG - difF * m % BASE + BASE) % BASE;
      curF = (curF + toAdd) % BASE;
      g[i][j] = (g[i][j - 1] + curF * (n / j)) % BASE;
      f[i][j] = (f[i][j - 1] + curF) % BASE;
    }

  cout << f[k + 1][1] << endl;
}

```