#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <functional>
#include <bitset>
#include <numeric>
#include <complex>
#include <iomanip>
#include <cassert>
#include <random>

#line 1 "lib/modint.hpp"



#include <iostream>

// Modint
struct Mint {
    static const long long mod = (long long)1e9 + 7;
    long long val;

    Mint() { val = 0; }
    Mint(long long a) { val = a; verify_value(); }

    void verify_value() {
        if (val >= mod) val %= mod;
        if (val < 0) val %= mod, val += mod;
    }

    Mint pow(long long p) const {
        Mint cur = Mint(val), ret = 1;
        while (p > 0) {
            if (p & 1) ret *= cur;
            cur *= cur;
            p >>= 1LL;
        }
        return ret;
    }
    Mint inv() const {
        if (val == 0)
            std::cerr << "WARNING: inv() is called with 0." << std::endl;
        return pow(mod - 2);
    }

    Mint operator+() const { return *this; }
    Mint operator-() const { return Mint(mod - val); }

    Mint operator+=(const Mint &a) {
        val += a.val;
        if (val >= mod) val -= mod;
        return Mint(val);
    }
    Mint operator*=(const Mint &a) {
        val *= a.val;
        if (val >= mod) val %= mod;
        return Mint(val);
    }
    Mint operator-=(const Mint &a) { return *this += -a; }
    Mint operator/=(const Mint &a) { return *this *= a.inv(); }

    Mint operator++() { return *this += Mint(1); }
    Mint operator--() { return *this -= Mint(1); }
    Mint operator++(int) {
        Mint ret = *this;
        ++(*this);
        return ret;
    }
    Mint operator--(int) {
        Mint ret = *this;
        --(*this);
        return ret;
    }

    operator long long() const { return val; }
};

Mint operator+(const Mint &a, const Mint &b) {
    long long ret = a.val + b.val;
    if (ret >= Mint::mod) ret -= Mint::mod;
    return Mint(ret);
}
Mint operator*(const Mint &a, const Mint &b) {
    long long ret = a.val * b.val;
    if (ret >= Mint::mod) ret %= Mint::mod;
    return Mint(ret);
}
Mint operator-(const Mint &a, const Mint &b) { return a + (-b); }
Mint operator/(const Mint &a, const Mint &b) { return a * b.inv(); }

std::ostream &operator<<(std::ostream &out, const Mint &a) { return out << a.val; }
std::istream &operator>>(std::istream &in, Mint &a) {
    in >> a.val;
    a.verify_value();
    return in;
}

Mint pow(Mint a, long long b) {
    return a.pow(b);
}


int main() {
    long long n, k; std::cin >> n >> k;
    long long rtn = 1;
    while (rtn*rtn <= n) rtn++; rtn--;
    std::vector<long long> di, cnt;
    for (long long i = 1; i <= rtn; i++) {
        di.push_back(n / i);
        cnt.push_back(1);
    }
    for (long long i = di.back() - 1; i >= 1; i--) {
        long long lo = rtn - 1, hi = 1e9 + 1;
        while (hi - lo > 1) {
            long long mid = lo + (hi - lo) / 2;
            if (n / mid > i) lo = mid;
            else hi = mid;
        }
        long long left = hi;
        lo = rtn - 1, hi = 1e9 + 1;
        while (hi - lo > 1) {
            long long mid = lo + (hi - lo) / 2;
            if (n / mid >= i) lo = mid;
            else hi = mid;
        }
        long long right = hi;
        di.push_back(i);
        cnt.push_back(right - left);
    }
    std::vector<long long> cntacc(cnt.begin(), cnt.end());
    for (int i = 0; i < (int)cnt.size() - 1; i++) {
        cntacc[i + 1] += cntacc[i];
    }
    std::vector<Mint>
        dp(di.size() + 2, 1), nxt(di.size() + 2), acc(di.size() + 2);
    for (int t = 0; t < k; t++) {
        for (int i = 0; i < (int)di.size(); i++) {
            acc[i] = (i > 0 ? acc[i - 1] : Mint(0)) + dp[i] * Mint(cnt[i]);
        }
        for (int i = 0; i < (int)di.size(); i++) {
            nxt[i] = 0;
            auto j = std::lower_bound(cntacc.begin(), cntacc.end(), di[i])
                - cntacc.begin();
            if (j > 0) nxt[i] += acc[j - 1];
            nxt[i] += dp[j] * Mint(di[i] - (j > 0 ? cntacc[j - 1] : 0));
        }
        std::swap(dp, nxt);
    }
    std::cout << dp[0] << std::endl;
    return 0;
}


Measured memory_bytes: 3444