#include <bits/stdc++.h>
using namespace std;

#define MOD 1000000007

class Mod
{
public:
    long long value;
    long long mod;
    Mod(long long x, long long m = 1000000007)
    {
        set_mod(m);
        set_value(x);
    }

    void set_mod(long long m)
    {
        this->mod = m;
    }

    void set_value(long long x)
    {
        this->value = x % this->mod;
    }

    friend ostream &operator<<(ostream &os, const Mod &x)
    {
        os << x.value;
        return os;
    }

    Mod &operator=(const long long x)
    {
        this->value = x;
        return *this;
    }

    Mod &operator+=(const long long x)
    {
        this->value = (this->value + x) % this->mod;
        return *this;
    }

    Mod &operator+=(const Mod x)
    {
        *this += x.value;
        return *this;
    }

    Mod &operator-=(const long long x)
    {
        this->value = (this->value - x) % this->mod;
        return *this;
    }

    Mod &operator-=(const Mod x)
    {
        *this -= x.value;
        return *this;
    }

    Mod &operator*=(const long long x)
    {
        this->value = (this->value * x) % this->mod;
        return *this;
    }

    Mod &operator*=(const Mod x)
    {
        *this *= x.value;
        return *this;
    }

    Mod &operator/=(const long long x)
    {
        long long a = x;
        long long b = this->mod;
        long long u = 1;
        long long v = 0;
        while (b)
        {
            long long t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        u %= this->mod;
        if (u < 0)
            u += this->mod;
        *this *= Mod(u, this->mod);
        return *this;
    }

    Mod &operator/=(const Mod x)
    {
        *this /= x.value;
        return *this;
    }

    Mod operator+(const long long x) const
    {
        return Mod(*this) += x;
    }

    Mod operator+(const Mod x) const
    {
        return Mod(*this) += x;
    }

    Mod operator-(const long long x) const
    {
        return Mod(*this) -= x;
    }

    Mod operator-(const Mod x) const
    {
        return Mod(*this) -= x;
    }

    Mod operator*(const long long x) const
    {
        return Mod(*this) *= x;
    }

    Mod operator*(const Mod x) const
    {
        return Mod(*this) *= x;
    }

    Mod operator/(const long long x) const
    {
        return Mod(*this) /= x;
    }

    Mod operator/(const Mod x) const
    {
        return Mod(*this) /= x;
    }
};

int main()
{
    int N, K;
    cin >> N >> K;

    map<int, int> count;
    for (int i = 1; i * i <= N; i++)
    {
        count[i] = 0;
        count[N / i] = 0;
    }

    int pre = 0;
    int idx = 0;
    map<int, int> dict;
    for (auto itr = count.begin(); itr != count.end(); itr++, idx++)
    {
        count[itr->first] = itr->first - pre;
        pre = itr->first;

        dict[idx] = itr->first;
    }

    vector<vector<Mod>> dp(K + 1, vector<Mod>(count.size(), Mod(0, MOD)));
    dp[0][0] = 1;

    for (int i = 1; i <= K; i++)
    {
        Mod sum(0, MOD);
        for (int j = count.size() - 1; j >= 0; j--)
        {
            sum += dp[i - 1][count.size() - j - 1];
            dp[i][j] = sum * count[dict[j]];
        }
    }

    Mod ans(0, MOD);
    for (Mod v : dp.back())
    {
        ans += v;
    }
    cout << ans << endl;
}


Measured memory_bytes: 108448