#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#define repi(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define all(a) (a).begin(), (a).end()

using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll mod = 1000000007;

ll N, K;
std::vector<ll> S;
std::map<ll, ll> inv;

int main()
{
  scanf( "%lld%lld", &N, &K );

  for( int j = 1; j*j <= N; ++j )
  {
    S.push_back( j );
    S.push_back( N/j );
  }

  std::sort( all(S) );
  S.erase( std::unique(all(S)), S.end() );

  rep( i, S.size() )
    inv[S[i]] = i;

  std::vector<std::vector<ll>> dp( K+1, std::vector<ll>( S.size()+1, 0 ) );

  rep( j, S.size() )
    dp[0][j] = 1;

  rep( i, K )
  {
    rep( j, S.size() )
    {
      dp[i+1][j] = (dp[i+1][j]+dp[i][inv[N/S[j]]]*(S[j]-(j>0?S[j-1]:0))%mod)%mod;

      dp[i+1][j+1] = (dp[i+1][j+1]+dp[i+1][j])%mod;
    }
  }

  printf( "%lld\n", dp[K][S.size()] );

  return 0;
}
### 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 <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#define repi(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define all(a) (a).begin(), (a).end()

using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll mod = 1000000007;

ll N, K;
std::vector<ll> S;
std::map<ll, ll> inv;

int main()
{
  scanf( "%lld%lld", &N, &K );

  for( int j = 1; j*j <= N; ++j )
  {
    S.push_back( j );
    S.push_back( N/j );
  }

  std::sort( all(S) );
  S.erase( std::unique(all(S)), S.end() );

  rep( i, S.size() )
    inv[S[i]] = i;

  std::vector<std::vector<ll>> dp( K+1, std::vector<ll>( S.size()+1, 0 ) );

  rep( j, S.size() )
    dp[0][j] = 1;

  rep( i, K )
  {
    rep( j, S.size() )
    {
      dp[i+1][j] = (dp[i+1][j]+dp[i][inv[N/S[j]]]*(S[j]-(j>0?S[j-1]:0))%mod)%mod;

      dp[i+1][j+1] = (dp[i+1][j+1]+dp[i+1][j])%mod;
    }
  }

  printf( "%lld\n", dp[K][S.size()] );

  return 0;
}
```