import java.lang.Math

fun main(args: Array<String>) {
    val mod = 1000000007L
    val N = readInputLine().toCharArray()
    val K = readInputLine().toInt()

    if (N.size < K) {
        println(0)
        return
    }

    val factorial = LongArray(N.size + 1)
    val inverse = LongArray(N.size + 1)
    val factorialInverse = LongArray(N.size + 1)
    factorial[0] = 1L
    factorial[1] = 1L
    inverse[0] = 1L
    inverse[1] = 1L
    factorialInverse[0] = 1L
    factorialInverse[1] = 1L
    for (i in 2..N.size) {
        factorial[i] = (factorial[i - 1] * i.toLong() % mod)
        inverse[i] = (mod - inverse[mod.toInt() % i] * (mod / i.toLong()) % mod)
        factorialInverse[i] = (factorialInverse[i - 1] * inverse[i] % mod)
    }

    // まずはNの桁数の値すべてを使える場合の組み合わせ数を求める
    var ans = factorial[N.size] * (factorialInverse[K] * factorialInverse[N.size - K] % mod) % mod
    for (i in 1..K) {
        ans *= 9L
        ans %= mod
    }

    // 指定数を超過する数を消す
    var usedCnt = 0

    for (i in N.indices) {
        if (N[i] != '0') {
            usedCnt++
        }

        if (N.size - (i + 1) >= 0) {
            var subTmp =
                factorial[N.size - (i + 1)] * (factorialInverse[K - usedCnt] * factorialInverse[Math.max(0, N.size - (i + 1) - (K - usedCnt))] % mod) % mod * (9L - (N[i] - '0')) % mod
            for (j in 1..K - usedCnt - if (N[i] == '0') 1 else 0) {
                subTmp *= 9L
            }

            ans -= subTmp
        }

        if (usedCnt == K) {
            break
        }
    }

    println(Math.max(0, ans))
}

fun readInputLine(): String {
    return readLine()!!
}
