#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<unordered_map>
#include<climits>
#include<cstdlib>
#include<cmath>
#include<string>
#include<iomanip>
#include<bitset>
#include<list>

using namespace std;

#define ll long long int

ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;

ll mypow(ll x,ll n,ll mod = MOD){
    ll ret = 1;
    while(n > 0){
        if(n&1){
            ret = (ret*x)%mod;
        }
        x = (x*x)%mod;
        n >>= 1;
    }
    return ret;
}

ll mygcd(ll a,ll b){
    if(b == 0)return a;
    return mygcd(b,a%b);
}

ll twoPow(ll shiftNum){
    return (1LL << (shiftNum - 1));
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
 
    ll n,k;
    cin >> n >> k;

    set<ll> st;
    for(ll i = 1; i*i <= n; i++){
        st.insert(i);
        st.insert(n/i);
    }

    map<ll,ll> mp;

    ll ok = n+1;
    ll ng = 0;
    for(auto itr = st.begin(); itr != st.end(); itr++){
        ll t = *itr;
        ll tok = ok;
        ll tng = ng;
        while(abs(tok - tng) > 1){
            ll middle = (tok + tng)/2;
            if(n/middle > t){
                tng = middle;
            }else{
                tok = middle;
            }
        }
        mp.insert({t,ok - tok});
        ok = tok;
    }

    vector<ll> num;
    for(auto itr = mp.begin(); itr != mp.end(); itr++){
        num.push_back((*itr).second);
    }
    vector<ll> dp1(num.size(),0),dp2(num.size(),0);
    dp2[0] = 1;

    for(int i = 0; i < k; i++){
        ll sum = 0;
        if(i%2 == 0){
            for(int i = dp1.size() - 1; i >= 0; i--){
                sum += dp2[dp1.size() - 1 - i];
                sum %= MOD;
                dp1[i] = (sum*num[dp1.size() - 1 - i])%MOD;
            }
        }else{
            for(int i = dp2.size() - 1; i >= 0; i--){
                sum += dp1[dp2.size() - 1 - i];
                sum %= MOD;
                dp2[i] = (sum*num[dp2.size() - 1 - i])%MOD;
            }
        }
    }

    ll ans = 0;

    if(k%2 != 0){
        for(int i = 0; i < dp1.size(); i++){
            ans += dp1[i];
            ans %= MOD;
        }
    }else{
        for(int i = 0; i < dp2.size(); i++){
            ans += dp2[i];
            ans %= MOD;
        }
    }

    cout << ans << endl;
    
    /*map<ll,ll> dp1,dp2;
    for(auto itr = dp1.begin(); itr != dp1.end(); itr++){
        dp2.insert({(*itr).first,0});
    }

    dp2[n] = 1;

    for(int i = 0; i < k; i++){
        ll sum = 0;
        if(i%2 == 0){
            for(auto itr = mp.begin(); itr != mp.end(); itr++){
                auto x = *itr;
                auto y = dp2[n/x.first];
                sum += y;
                sum %= MOD;
                dp2.erase(n/x.first);
                dp1.insert({x.first,sum*x.second});
            }
        }else{
            for(auto itr = mp.begin(); itr != mp.end(); itr++){
                auto x = *itr;
                auto y = dp1[n/x.first];
                sum += y;
                sum %= MOD;
                dp1.erase(n/x.first);
                dp2.insert({x.first,sum*x.second});
            }
        }
    }

    ll ans = 0;

    if(k%2 == 0){
        for(auto itr = dp2.begin(); itr != dp2.end(); itr++){
            ans += (*itr).second;
            ans %= MOD;
        }
    }else{
        for(auto itr = dp1.begin(); itr != dp1.end(); itr++){
            ans += (*itr).second;
            ans %= MOD;
        }
    }

    cout << ans << endl;
    */

    return 0;
}

Measured memory_bytes: 8828