#include"bits/stdc++.h"
#include<boost/multi_array.hpp>
#include<boost/optional.hpp>
#include<boost/range/irange.hpp>
#include<boost/range/algorithm.hpp>
#include<boost/range/adaptors.hpp>
#include<boost/operators.hpp>
#include<boost/dynamic_bitset.hpp>
namespace adaptor = boost::adaptors;
template<class T>using p_queue = std::priority_queue<T, std::vector<T>, std::greater<>>;

namespace lib
{
	template<class T>constexpr T pow(T val, std::uint64_t p)
	{
		auto ret = T(1);
		for (auto i : boost::irange(0, 63))
		{
			if (p & (1ULL << i))
			{
				ret *= val;
			}
			val *= val;
		}
		return ret;
	}
	template<std::uint64_t Mod>class modnum :
		private boost::addable<modnum<Mod>>,
		private boost::subtractable<modnum<Mod>>,
		private boost::multipliable<modnum<Mod>>,
		private boost::dividable<modnum<Mod>>
	{
		std::uint64_t val;
		void clamp()
		{
			val %= Mod;
		}
	public:
		modnum() = default;
		modnum(std::int64_t v) :val()
		{
			if (v < 0)
			{
				v += (std::abs(v) / Mod + 1) * Mod;
			}
			val = v;
			clamp();
		}
		modnum(std::uint64_t v) :val(v)
		{
			clamp();
		}
		modnum(std::int32_t v) :modnum(static_cast<std::int64_t>(v))
		{

		}
		modnum(std::uint32_t v) :modnum(static_cast<std::uint64_t>(v))
		{

		}
		friend std::ostream& operator<<(std::ostream& os, modnum const& num)
		{
			return os << num.val;
		}
		auto& operator+=(modnum const& rhs)
		{
			val += rhs.val;
			clamp();
			return *this;
		}
		auto& operator-=(modnum const& rhs)
		{
			val += Mod - rhs.val;
			clamp();
			return *this;
		}
		auto& operator*=(modnum const& rhs)
		{
			val *= rhs.val;
			clamp();
			return *this;
		}
		auto& operator/=(modnum const& rhs)
		{
			val *= pow(rhs, Mod - 2).val;
			clamp();
			return *this;
		}
		auto const& operator*()const
		{
			return val;
		}
	};
}
using mod_t = lib::modnum<1000000007>;

namespace lib
{
	template<class T>constexpr auto sqrt(T const& v)
		->std::enable_if_t<std::is_integral<T>::value, T>
	{
		if (v < T())
		{
			return std::numeric_limits<T>::max();
		}
		else if (v == T())
		{
			return T();
		}
		auto ret = T();
		while (ret * ret < v)
		{
			if ((ret + 1) * (ret + 1) > v)
			{
				return ret;
			}
			++ret;
		}
		return ret;
	}
}

void Main()
{
	int N, K;
	std::cin >> N >> K;
	if (N == 1)
	{
		std::cout << 1 << std::endl;
		return;
	}
	auto n = lib::sqrt(N);
	std::vector<mod_t> prod(1);
	auto rng = boost::irange(n + 1, N);
	auto end = rng.end();
	for (int i = 1; i <= n; ++i)
	{
		auto p = std::partition_point(rng.begin(), end, [&](int x)
			{
				return N / x != i;
			});
		--p;
		prod.emplace_back(end - p);
		end = p;
	}
	std::vector<mod_t> lower(n + 1);
	std::vector<mod_t> upper(n + 1);
	for (int i : boost::irange(1, n + 1))
	{
		lower[i] = lower[i - 1] + 1;
	}
	upper[n] = prod[n];
	for (int i : boost::irange(0, n) | adaptor::reversed)
	{
		upper[i] = upper[i + 1] + prod[i];
	}
	lower[0] = 0;
	for (int i : boost::irange(1, K))
	{
		std::vector<mod_t> nlower(n + 1);
		std::vector<mod_t> nupper(n + 1);
		nupper[n] = lower[n] * prod[n];

		for (int k : boost::irange(1, n + 1))
		{
			nlower[k] = nlower[k - 1] + lower[n] + upper[k];
		}
		for (int k : boost::irange(1, n) | adaptor::reversed)
		{
			nupper[k] = nupper[k + 1] + lower[k] * prod[k];
		}
		std::swap(nlower, lower);
		std::swap(nupper, upper);
	}
	std::cout << lower[n] + upper[1] << std::endl;
}

int main()
{
	std::cin.tie(nullptr);
	std::ios_base::sync_with_stdio(false);
	std::cout << std::fixed << std::setprecision(15);
	Main();
}

Measured memory_bytes: 1660