#include <numeric>
#include <cmath>
#include <iostream>
using namespace std;
constexpr int M = 1000000007;

int main() {
    int N, K; cin >> N >> K;
    if (N == 1) { cout << 1 << endl; return 0; }
    const int b = int(sqrt(N)) + 2;
    long long dps[2][b], dpl[2][b];
    int cur = 0, prev = 1;
    dps[0][0] = dps[1][0] = dpl[0][0] = dpl[1][0] = 0;
    for (int i = 1; i < b; i++) {
        dps[prev][i] = i;
        dpl[prev][i] = N/i;
    }
    while (--K) {
        for (int i = 1; i < b; i++) {
            dps[cur][i] = (dps[cur][i-1] + (N/i < b ? dps[prev][N/i] : dpl[prev][i])) % M;
        }
        for (int i = b-1; i > 0; i--) {
            dpl[cur][i] = ((i == b-1 ? dps[cur][N/b] : dpl[cur][i+1]) +
                           (N/(N/i) < b ? dps[prev][N/(N/i)] : dpl[prev][N/i])
                           * (N/i - N/(i+1))) % M;
        }
        swap(prev, cur);
    }
    cout << dpl[prev][1] << endl;
}

### Prompt

Create a solution in cpp for 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 <numeric>
#include <cmath>
#include <iostream>
using namespace std;
constexpr int M = 1000000007;

int main() {
    int N, K; cin >> N >> K;
    if (N == 1) { cout << 1 << endl; return 0; }
    const int b = int(sqrt(N)) + 2;
    long long dps[2][b], dpl[2][b];
    int cur = 0, prev = 1;
    dps[0][0] = dps[1][0] = dpl[0][0] = dpl[1][0] = 0;
    for (int i = 1; i < b; i++) {
        dps[prev][i] = i;
        dpl[prev][i] = N/i;
    }
    while (--K) {
        for (int i = 1; i < b; i++) {
            dps[cur][i] = (dps[cur][i-1] + (N/i < b ? dps[prev][N/i] : dpl[prev][i])) % M;
        }
        for (int i = b-1; i > 0; i--) {
            dpl[cur][i] = ((i == b-1 ? dps[cur][N/b] : dpl[cur][i+1]) +
                           (N/(N/i) < b ? dps[prev][N/(N/i)] : dpl[prev][N/i])
                           * (N/i - N/(i+1))) % M;
        }
        swap(prev, cur);
    }
    cout << dpl[prev][1] << endl;
}

```