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

#include <cstdlib>

#include <cmath>

#include <iostream>

#include <algorithm>

#include <utility>

#include <functional>

#include <string>

#include <vector>

#include <deque>

#include <queue>

#include <stack>

#include <list>

#include <set>

#include <map>

#include <unordered_map>

#include <iomanip>

#include <numeric>

#include <complex>

#include <cassert>



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;

    int dig = 1;

    dp[0][0] = 1;

    reverse(all(s));

    rep(i, s.size()){

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

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

            rep(k, 13){

                dp[i+1][(c*dig + k)%13] += dp[i][k];

            }

        }else{

            rep(j, 10){

                rep(k, 13){

                    dp[i+1][((j*dig + k)%13)] += dp[i][k];

                }

            }

        }

        dig =dig*10%13;

    }

    

    cout << dp[(int)s.size()][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: