#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template<class T, class U> inline bool chmax(T& a,U b) { if (a < b) { a = b; return 1; } return 0; }
template<class T, class U> inline bool chmin(T& a,U b) { if (a > b) { a = b; return 1; } return 0; }
constexpr int MAX_K = 110;
constexpr int MOD = 1e9+7;
template<int mod> struct ModInt {
    int x;
    ModInt() : x(0) {}
    ModInt(long long y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
    ModInt &operator+=(const ModInt &p) { if((x += p.x) >= mod) x -= mod; return *this; }
    ModInt &operator-=(const ModInt &p) { if((x += mod-p.x) >= mod) x -= mod; return *this; }
    ModInt &operator*=(const ModInt &p) { x = (int)(1LL*x*p.x%mod); return *this; }
    ModInt &operator/=(const ModInt &p) { *this *= p.inverse(); return *this; }
    ModInt operator-() const { return ModInt(-x); }
    ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
    ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
    ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
    ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
    bool operator==(const ModInt &p) const { return x == p.x; }
    bool operator!=(const ModInt &p) const { return x != p.x; }
    ModInt inverse() const{
        int a = x, b = mod, u = 1, v = 0, t;
        while(b > 0) { t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); }
        return ModInt(u);
    }
    ModInt pow(int e){
        long long a = 1, p = x;
        while(e > 0) {
            if(e%2 == 0) {p = (p*p) % mod; e /= 2;}
            else {a = (a*p) % mod; e--;}
        }
        return ModInt(a);
    }
    friend ostream &operator<<(ostream &os, const ModInt<mod> &p) {
        return os << p.x;
    }
    friend istream &operator>>(istream &is, ModInt<mod> &a) {
        long long x;
        is >> x;
        a = ModInt<mod>(x);
        return (is);
    }
};

template<typename T> struct SegmentTree {
    using F = function<T(T, T)>;
private : 
    int n;
    T id;
    F f;
    vector<T> node;

public : 
    SegmentTree (int sz, const F &f, const T &id) : n(1), f(f), id(id) {
        while (n <= sz) n <<= 1;
        node.resize(2*n, id);
    }

    SegmentTree (const vector<T> &v, const F &f, const T &id) : n(1), f(f), id(id) {
        while (n <= (int)v.size()) n <<= 1;
        node.resize(2*n, id);
        for (int i = 0; i < (int)v.size(); i++) {
            node[i+n] = v[i];
        }
        for (int i = n-1; i > 0; i--) {
            node[i] = f(node[i<<1], node[i<<1|1]);
        }
    }

    void update (int i, const T &x) {
        i += n;
        assert(i < node.size());
        node[i] = x;
        while (i > 0) {
            i >>= 1;
            node[i] = f(node[i<<1], node[i<<1|1]);
        }
    }

    const T query (int l, int r) const {
        T vl = id, vr = id;
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l&1) vl = f(vl, node[l++]);
            if (r&1) vr = f(node[--r], vr);
        }
        return f(vl, vr);
    }

    const T &operator[] (int i) const { return node[i+n]; }

};

template<typename T> vector<pair<pair<T, T>, T>> quotient (T N) {
    T M;
    vector<pair<pair<T, T>, T>> ret;
    for(M = 1; M * M <= N; M++) {
        ret.emplace_back(make_pair(M, M), N/M);
    }
    for(T i = M; i > 0; i--) {
        T L = N/(i+1) + 1;
        T R = N/i;
        if(L <= R && ret.back().first.second < L) {
            ret.emplace_back(make_pair(L, R), N/L);
        }
    }
    return ret;
}

int main() {
    using mint = ModInt<MOD>;
    int n, k;
    cin >> n >> k;
    map<int, int> idx;
    vector<pair<pair<int, int>, int>> quo = quotient(n);
    int m = quo.size();
    vector<int> range(m);
    for (int i = 0; i < m; i++) {
        idx[quo[i].first.second] = i;
        range[i] = abs(quo[i].first.second - quo[i].first.first) + 1;
    }
    
    auto f = [] (mint a, mint b) { return a + b; };
    vector<SegmentTree<mint>> seg(k+1, SegmentTree<mint>(m+1, f, 0));
    
    seg[0].update(0, 1);
    
    for (int i = 0; i < k; i++) {
        for (int j = 0; j < m; j++) {
            int val = n / quo[j].first.second;
            int id = idx[val];
            mint res = seg[i].query(0, id+1) * range[j];
            seg[i+1].update(j, res);
        }
    }
    
    cout << seg[k].query(0, m+1) << endl;
    return 0;
}

Measured memory_bytes: 56824