#include <iostream>
#include <stdlib.h>
#include <vector> //vector
#include <algorithm> //sort()
#include <numeric>
#include <tuple>
#include <cmath>

#define rep(i, n) for(int i=0; i<(int)(n);i++)
#define all(x) (x).begin(), (x).end()
#define debug(a) if(flagdebug){cout << "debug (" #a "):" << endl << (a) << endl;}

typedef uint64_t ulint;
typedef int64_t lint;
// int64の最大値
// -9223372036854775808 ~ 9223372036854775807

using namespace std;

template<class T> inline bool chmin(T& a, T b);
template<class T> inline bool chmax(T& a, T b);
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v);

template<class T> lint sum(vector<T> a);
template<class T> double ave(vector<T> a);

// struct pos
// {
//     lint x;
//     lint y;
//     lint dist;

// public:
//     pos(lint ax, lint ay, lint ad)
//     {
//         x = ax;
//         y = ay;
//         dist = ad;
//     }
    
// };

lint n, k;
lint h, w;

bool flagdebug = false;


int main(){
//////////////////////////////////////////////////////

    //flagdebug = true; ///本番時削除！！！！！

    string s;

    cin >> s;

    lint digit = s.length();

    vector<vector<lint>> dp(digit+1,vector<lint>(13,0));

    debug(digit);

    //debug(s[0]);
    //debug("aaa");

    lint deci = 1;

    //dpを下から解く
    rep(i,digit+1)
    {
        if(i==0)
        {
            dp[0][0]=1;
            continue;
        }
        if(s[digit-i] == '?')
        {
            rep(j,10)
            {
                rep(k,13)
                {
                    dp[i][(j*deci+k)%13] += dp[i-1][k];
                    if(dp[i][(j*deci+k)%13] > 1000000007)dp[i][(j*deci+k)%13] %= 1000000007;
                }
            }
        }
        else
        {
            int c = s[digit-i] - '0';
            rep(k,13)
            {
                dp[i][(c*deci+k)%13] += dp[i-1][k];
            }
        }
        deci *= 10;
        deci %= 13;
    }
    debug(deci);
    debug(dp);
    cout << dp[digit][5] << endl;


    //2次元配列
    //vector<vector<lint>> mat(row, vector<lint>(column, 初期値));
    //ペア
    //fpair<lint,lint> p = make_pair(1,2);
    //タプル
    //tuple<lint,lint,lint> t  = make_tuple(1,2,3);


    //昇順ソート
    //sort(all(a));

    //////////////////////////////////////////////////////
    //キュー
    //queue<lint> que;
    //que.push(value);
    //que.front(); //先頭を参照
    //que.pop; //追い出す
    //////////////////////////////////////////////////////
    //スタック
    //stack<lint> stk;
    //stk.push(value);
    //stk.top(); //先頭を参照
    //stk.pop(); //トップを削除
    //stk.empty(); //空なら1,あれば0
    //stk.size(); //数
    //


   

    // sort(input.begin() , input.end());

    // uint64_t max = numeric_limits<uint64_t>::max();


    //////////////////////////////////////////////////////
    // DP

//     // 無限大の値
//     const uint64_t INF = (uint64_t)1 << 60;
//     //const int64_t NINF = -1 * ((int64_t)1 << 60 );
 
//     // DP テーブル
//     uint64_t dp[100010];

//     //DPテーブル初期化（最小化用）
//     for (int i = 0; i < 100010; ++i)
//     {
//         //dp[i] = INF;
//         dp[i] = 0;
//     } 

//     // 初期条件
//     dp[0] = 0;

//     // ループ
//     for (int i = 1; i <= n; ++i) {
//         //chmin( dp[i], dp[i - 1] + abs( input[i] - input[i - 1] ));
//         //if (i < 2)continue;
//         //chmin( dp[i], dp[i - 2] + abs( input[i] - input[i - 2] ));



//         // chmax ( dp [i] , dp[i - 1]);
//         // chmax ( dp [i] , dp[i - 1] + input[i]);
//         // cout << "dp[" << i <<"] = " << dp[i] << endl;

//     }



// //////////////////////////////////////////////////////

//     cout << dp[n] << endl;

//////////////////////////////////////////////////////
// Ctrl + Opt + N to make
    return 0;
}


//最小化用関数
template<class T> inline bool chmin(T& a, T b)
{
    if (a > b) 
    {
        a = b;
        return true;
    }
    return false;
}

//最大化関数
template<class T> inline bool chmax(T& a, T b)
{
    if (a < b)
    {
        a = b;
        return true;
    }
    return false;
}


// vectorprint用
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
	int len = v.size();
	for (int i = 0; i < len; ++i) {
		s << v[i]; if (i < len - 1) s << "\t";
	}
	return s;
}

// //合計
// template<class T> lint sum(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0);
// }


// //平均
// template<class T> double ave(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0.0) / a.size();
// }



Measured memory_bytes: 13696