fun main(args: Array<String>) {
    val s = readLine()!!

    // 解説参考
    // mod 計算は桁ごとに分解できる
    // そして桁ごとの計算結果を dp に格納することによって計算量を削減できる

    val modVal = (1e9 + 7).toInt()
    val dp = Array(s.length) { IntArray(13) { 0 } }

    val sRev = s.reversed()

    // dp の一桁目を初期化
    if (sRev[0] != '?') {
        dp[0][sRev[0].toString().toInt() % 13] = 1
    } else {
        for (i in 0..9) {
            dp[0][i] = 1
        }
    }

    // dp の二桁目以降を求める
    for (i in 1 until s.length) {
        val c = sRev[i]

        if (c != '?') {
            // 10の i 乗 は値が大きくなるとオーバーフローするので注意
            val res = (c.toString().toInt() * powMod(10, i.toLong(), 13)) % 13

            // 既存の結果から i 桁目の対しての dp 計算
            for (j in 0..12) {
                val index = (res + j) % 13
                dp[i][index.toInt()] = (dp[i][index.toInt()] + dp[i - 1][j]) % modVal
            }
        } else {
            for (j in 0..9) {
                val res = (j * powMod(10, i.toLong(), 13)) % 13

                // 既存の結果から i 桁目に対しての dp計算
                for (k in 0..12) {
                    val index = (res + k) % 13
                    dp[i][index.toInt()] = (dp[i][index.toInt()] + dp[i - 1][k]) % modVal
                }
            }
        }
    }

    println(dp[s.length - 1][5])
}


/**
 * a^n mod modVal を計算する
 * 二分累乗法で累乗計算を O(logN) で行いつつ，OverFlow を避けるため適宜 mod 計算を行う
 */
fun powMod(a: Long, n: Long, modVal: Long, ans: Long = 1): Long {

    if (n == 0L) {
        return ans
    }

    // ビット演算の結果 2^0 の桁が 0 の場合は ans に掛けずに次の桁へ
    if (n.and(1L) == 0L) {
        return powMod(a * a % modVal, n.shr(1), modVal, ans)
    }

    // ビット演算の結果 2^9 の桁が 1 の場合は ans を更新
    return powMod(a * a % modVal, n.shr(1), modVal, ans * a % modVal)
}