// Original C++ solution (slower):
#include <algorithm>

#include <cassert>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <deque>

#include <functional>

#include <iomanip>

#include <iostream>

#include <list>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>



using namespace std;

using ll = long long;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

#define all(x) (x).begin(), (x).end()

const int INF = (1 << 30);

const ll INFL = (1LL << 62);

const ll MOD = 1000000007;

template <class T>

bool chmin(T &a, T b) {

    if (a > b) {

        a = b;

        return true;

    }

    return false;

}

template <class T>

bool chmax(T &a, T b) {

    if (a < b) {

        a = b;

        return true;

    }

    return false;

}

template <class T>

T gcd(T a, T b) {

    return b ? gcd(b, a % b) : a;

}

template <class T>

T lcm(T a, T b) {

    return a / gcd(a, b) * b;

}

template <class T>

ll mod_pow(ll a, ll n, T mod) {

    mod = (ll)mod;

    ll res = 1, p = a % mod;

    while (n) {

        if (n & 1) res = res * p % mod;

        p = p * p % mod;

        n >>= 1;

    }

    return res;

}



template <int mod>

struct ModInt {

    using ll = long long;

    ll x;

    ModInt() : x(0) {}

    ModInt(int y) : x(y >= 0 ? ll(y % mod) : (ll)((mod - (-y) % mod))) {}

    ModInt(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod)) {}

    ModInt &operator+=(const ModInt &rhs) {

        if ((x += rhs.x) >= mod) x -= mod;

        return *this;

    }

    ModInt &operator-=(const ModInt &rhs) {

        if ((x += mod - rhs.x) >= mod) x -= mod;

        return *this;

    }

    ModInt &operator*=(const ModInt &rhs) {

        x = x * rhs.x % mod;

        return *this;

    }

    ModInt &operator/=(const ModInt &rhs) {

        *this *= rhs.inverse();

        return *this;

    }

    ModInt operator-() const { return ModInt(-x); }

    ModInt operator+(const ModInt &rhs) const { return ModInt(*this) += rhs; }

    ModInt operator-(const ModInt &rhs) const { return ModInt(*this) -= rhs; }

    ModInt operator*(const ModInt &rhs) const { return ModInt(*this) *= rhs; }

    ModInt operator/(const ModInt &rhs) const { return ModInt(*this) /= rhs; }

    ModInt operator==(const ModInt &rhs) const { return x == rhs.x; }

    ModInt operator!=(const ModInt &rhs) const { return x != rhs.x; }

    friend ostream &operator<<(ostream &os, const ModInt &rhs) {

        return os << rhs.x;

    }

    friend istream &operator>>(istream &is, ModInt &rhs) {

        ll t;

        is >> t;

        rhs = ModInt<mod>(t);

        return (is);

    }



   private:

    ModInt inverse() const {

        ll a = x, u = 1LL, v = 0LL, t, b = (ll)mod;

        while (b > 0) {

            t = a / b;

            swap(a -= t * b, b);

            swap(u -= t * v, v);

        }

        return ModInt(u);

    }

};

using mint = ModInt<1000000007>;



mint dp[101010][13];



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

    string s;

    cin >> s;

    dp[0][0] = 1;

    const int N = s.size();

    reverse(all(s));

    int base = 1;

    rep(i, N) {

        if (s[i] != '?') {

            rep(j, 13) {

                int c = s[i] - '0';

                dp[i + 1][(c * base + j) % 13] += dp[i][j];

            }

        } else {

            rep(j, 13) {

                rep(k, 10) dp[i + 1][(k * base + j) % 13] += dp[i][j];

            }

        }

        base = base * 10 % 13;

    }

    cout << dp[N][5] << endl;



    return 0;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cassert>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <deque>

#include <functional>

#include <iomanip>

#include <iostream>

#include <list>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>



using namespace std;

using ll = long long;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

#define all(x) (x).begin(), (x).end()

const int INF = (1 << 30);

const ll INFL = (1LL << 62);

const ll MOD = 1000000007;

ll dp[101010][13];



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

    string s;

    cin >> s;

    dp[0][0] = 1;

    const int N = s.size();

    reverse(all(s));

    int base = 1;

    rep(i, N) {

        if (s[i] != '?') {

            rep(j, 13) {

                int c = s[i] - '0';

                (dp[i + 1][(c * base + j) % 13] += dp[i][j]) %= MOD;

            }

        } else {

            rep(j, 13) {

                rep(k, 10)(dp[i + 1][(k * base + j) % 13] += dp[i][j]) %= MOD;

            }

        }

        base = base * 10 % 13;

    }

    cout << dp[N][5] << endl;



    return 0;

}

// Fastest known solution for this problem: