#include <bits/stdc++.h>

using namespace std;

const int OO = 1e9;
const double EPS = 1e-9;

#define ndl cout << '\n'
#define sz(v) int(v.size())
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define present(a, x) (a.find(x) != a.end())
#ifdef LOCAL
#define db(...) ({cout << "> Line " << __LINE__  \
		<< ": "; _db(#__VA_ARGS__, __VA_ARGS__);})
#define RNG() rng()
#else
#define db(...) true
#define RNG() true
#endif

template<class T>
void _db(const char *dbStr, T e) {
	cout << dbStr << " = " << e << endl;
}
template<class T, class... L>
void _db(const char *dbStr, T e, L... r) {
  while(*dbStr != ',') cout << *dbStr++;
  cout << " = " << e << ','; _db(dbStr + 1, r...);
}
template<class S, class T>
ostream& operator<<(ostream& o, const map<S, T>& v) {
	o << "["; int i = 0;
	for (const pair<S, T>& pr : v) o << (!i++ ? "" : ", ") << "{"
	<< pr.fs << " : " << pr.sc << "}"; return o << "]";
}
template<template <class, class...> class S, class T, class... L>
ostream& operator<<(ostream& o, const S<T, L...>& v) {
	o << "["; int i = 0;
	for (const auto& e : v) o << (!i++ ? "" : ", ") << e;
	return o << "]";
}
template<class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& pr) {
	return o << "(" << pr.fs << ", " << pr.sc << ")";
}
ostream& operator<<(ostream& o, const string& s) {
	for (const char& c : s) o << c;
	return o;
}

template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class T> using VVV = VV<V<T>>;
using ll = long long;
using pii = pair<int, int>;
using vi = V<int>;
using vii = V<pii>;
using vvi = VV<int>;
using mii = map<int, int>;
using umii = unordered_map<int, int>;
using si = set<int>;
using usi = unordered_set<int>;


const int MX = 1000000005, MOD = 1000000007;
const int MX_SQRT = sqrt(MX) + 5;

int mem[105][MX_SQRT][2], sum[105][MX_SQRT][2], sumi[105][MX_SQRT][2];
int N, K, N_SQRT;


ll add(ll x, ll y) {
    x += y;
    while(x >= MOD)
        x -= MOD;
    while(x < 0)
        x += MOD;
    return x;
}

ll mul(ll x, ll y) {
    return (x * y) % MOD;
}

//int W(int i, int prev) {
//	return min(N / prev, N / i) - N_SQRT;
//}
//
//int dp(int idx, int prev, int diff) {
//
////	db(idx, prev, diff);
//
//	if (idx == K)
//		return (diff == 0 ? 1 : N / prev - N_SQRT);
//
//
//	int& ret = mem[idx][prev][diff];
//
//	if (ret != -1)
//		return ret;
//
//	ret = 0;
//
//	if (diff == 0) {
//		for (int i = 1; i <= N_SQRT; ++i) {
//			ret += dp(idx + 1, i, 0);
//		}
//		ret += dp(idx + 1, prev, 1);
//	} else {
//		for (int i = 1; i <= N_SQRT; ++i) {
//			ret += dp(idx + 1, i, 0) * W(i, prev);
//		}
//	}
//
//	return ret;
//}


int main() {
	#ifdef LOCAL
	auto stTime = clock();
	freopen("in.txt", "r", stdin);
	mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
	#endif
	ios::sync_with_stdio(false);
	cout.precision(10);
	cin.tie(0);

	cin >> N >> K;

	for (N_SQRT = 1;; ++N_SQRT) {
		if (N_SQRT * 1LL * N_SQRT > N)
			break;
	}

	--N_SQRT;

	db(N_SQRT);

//	memset(mem, -1, sizeof(mem));
//
//	cout << dp(0, 1, 0);


	for (int i = 1; i <= N_SQRT; ++i) {
		mem[K][i][0] = 1;
		sum[K][i][0] = (sum[K][i - 1][0] + mem[K][i][0]) % MOD;
		sumi[K][i][0] = (sumi[K][i - 1][0] + mem[K][i][0] * 1LL * (N / i)) % MOD;

		mem[K][i][1] = N / i - N_SQRT;
		sum[K][i][1] = (sum[K][i - 1][1] + mem[K][i][1]) % MOD;
		sumi[K][i][1] = (sumi[K][i - 1][1] + mem[K][i][1] * 1LL * (N / i)) % MOD;
	}

	for (int idx = K - 1; idx >= 0; --idx) {
		for (int prev = 1; prev <= N_SQRT; ++prev) {
			for (int diff = 0; diff <= 1; ++diff) {
				int& ret = mem[idx][prev][diff];
				if (diff == 0) {
//					for (int i = 1; i <= N_SQRT; ++i) {
//						ret += mem[idx + 1][i][0];
//					}
					ret = add(sum[idx + 1][N_SQRT][0], mem[idx + 1][prev][1]);
//					ret = (ret + mem[idx + 1][prev][1]) % MOD;
				} else {
//					for (int i = 1; i <= N_SQRT; ++i) {
//						ret = add(ret, mem[idx + 1][i][0] * W(i, prev));
//					}
					ret = mul(N / prev - N_SQRT, sum[idx + 1][prev][0]);
					ret = add(ret, -mul(N_SQRT, add(sum[idx + 1][N_SQRT][0], -sum[idx + 1][prev][0])));
					ret = add(ret, add(sumi[idx + 1][N_SQRT][0], -sumi[idx + 1][prev][0]));
//					ret = ((N / prev - N_SQRT) * 1LL * sum[idx + 1][prev][0]) % MOD;
//					ret = (ret - ((N_SQRT * 1LL * ((sum[idx + 1][N_SQRT][0] - sum[idx + 1][prev][0] + MOD) % MOD)) % MOD) + MOD) % MOD;
				}


				sum[idx][prev][diff] = (sum[idx][prev - 1][diff] + ret) % MOD;
				sumi[idx][prev][diff] = (sumi[idx][prev - 1][diff] + ret * 1LL * (N / prev)) % MOD;


			}
		}
	}


	cout << mem[0][1][0] << '\n';



	#ifdef LOCAL
	cout << "\n\n\nExecution time: " <<
		(clock() - stTime) * 1e3 / CLOCKS_PER_SEC << " ms" << endl;
	#endif
    return 0;
}


Measured memory_bytes: 78080