const val P = 1000000007L

fun main(args: Array<String>) {
    val (n, k) = readLine()!!.split(" ").map { it.toInt() }
    val list = mutableListOf<Pair<IntRange, Int>>()
    val r = Math.floor(Math.sqrt(n.toDouble())).toInt()
    for (i in 1..r) {
        list.add(Pair(i..i, n / i))
    }
    for (i in r downTo 1) {
        val l = Math.max(n / (i + 1) + 1, r + 1)
        val u = n / i
        if (l <= u) {
            list.add(Pair(l..u, i))
        }
    }
    // println(list)
    // println(list.size)
    val size = list.size
    val dp = Array(k, { LongArray(size) })
    for (i in 0 until size) {
        dp[0][i] = (list[i].first.last - list[i].first.first + 1).toLong()
    }
    var counter = 0L
    for (t in 1 until k) {
        val sum = LongArray(size)
        sum[0] = dp[t - 1][0]
        for (i in 1 until size) {
            sum[i] = sum[i - 1] + dp[t - 1][i]
        }


        dp[t][size - 1] = sum[0] * (list[size - 1].first.last - list[size - 1].first.first + 1)
        dp[t][size - 1] %= P
        for (i in size - 2 downTo 0) {
            dp[t][i] = sum[size - 1 - i]  * (list[i].first.last - list[i].first.first + 1)
            dp[t][i] %= P
//            val nextMax = list[i].second
//            for (j in 0 until size) {
//                counter++
//                if (list[j].first.last <= nextMax) {
//                    dp[t + 1][j] += dp[t][i] * (list[j].first.last - list[j].first.first + 1)
//                    dp[t + 1][j] %= P
//                } else if (list[j].first.first <= nextMax) {
//                    dp[t + 1][j] += dp[t][i] * (nextMax - list[j].first.first + 1)
//                    dp[t + 1][j] %= P
//                } else {
//                    break
//                }
//            }
        }
    }
    // println("counter: $counter")
//    println(dp[0].asList())
//    println(dp[k - 1].asList())
    var ans = 0L
    for (i in 0 until size) {
        ans += dp[k - 1][i]
        ans %= P
    }
    println(ans)
}