#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 
typedef long long int ll;
typedef unsigned long long ull;

#define int ll

typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
 
#define pb push_back 
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
 
#define mod 1000000007
// #define mod 998244353

// ################################## Debugging statements  ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true;  string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
 
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1;  int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
 
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
	rep(i, p){rep(j, s){rep(k, q){
				// C[i][j] += A[i][k] * B[k][j]; 
				C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
	}}}return C;}
 
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
 
// ###########################################################################################
 
// #################################### Combinatorics template ###############################
struct factorial{
	int N;int *fac;int *ifac;int MOD;
	factorial(int n, int m = 1000000007){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];pre_calc();}
	int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
	int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
	int multiply(int a, int b){return (int)((long long) a * b %MOD);}
	int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
	int inverse(int a){return binpow(a, MOD - 2);}
	void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
	int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
	int derangement(int n){
		if (n == 1) return 0;
		int ans = 0;
		for (int i = 2; i <= n ; i++){
			int sign = (i%2) ? -1 : 1;
			ans = add(ans, multiply(sign, fac[n]/fac[i]));
		}
		return ans;
	}
};

vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
 
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
	int *bit;int n;
	fenwick_tree(){this->n = 100005;this->bit = new int[100005+1];}
	fenwick_tree(int n){this->n = n;this->bit = new int[n+1];}
	void add(int i, int v){for (; i<=this->n; i+= i&-i)this->bit[i] += v;}
	int get(int i){int s = 0;for (; i; i -= i&-i){s += this->bit[i];}return s;}
};
// ###########################################################################################
 
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
 
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
 
// ###########################################################################################

// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################

// ###################################### Convex Hull Trick  ##################################
// struct Line {
//     mutable ll k, m, p;
//,     bool operator<(const Line& o) const { return k < o.k; }
//     bool operator<(ll x) const { return p < x; }
// };
 
// struct LineContainer : multiset<Line, less<>> {
//     // (for doubles, use inf = 1/.0, div(a,b) = a/b)
//     const ll inf = LLONG_MAX;
//     ll div(ll a, ll b) { // floored division
//         return a / b - ((a ^ b) < 0 && a % b); }
//     bool isect(iterator x, iterator y) {
//         if (y == end()) { x->p = inf; return false; }
//         if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
//         else x->p = div(y->m - x->m, x->k - y->k);
//         return x->p >= y->p;
//     }
//     void add(ll k, ll m) { // y = k * x + m
//         auto z = insert({k, m, 0}), y = z++, x = y;
//         while (isect(y, z)) z = erase(z);
//         if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
//         while ((y = x) != begin() && (--x)->p >= y->p)
//             isect(x, erase(y));
//     }
//     ll query(ll x) {
//         assert(!empty());
//         auto l = *lower_bound(x);
//         return l.k * x + l.m;
//     }
// };
// ###########################################################################################

int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};

// ################################### Template ends here ####################################

const int N = 1e5 + 5;
string s;
int dp[N][15];
int n;

int go(int idx, int rem){
	if (idx == n){
		return (rem == 5);
	}
	int &ans = dp[idx][rem];
	if (ans != -1)
		return ans;
	ans = 0;
	if (s[idx] == '?'){
		F(i, 0, 9){
			int nrem = 10 * rem + i;
			nrem %= 13;
			ans = add(ans, go(idx + 1, nrem));
		}
	}
	else{
		ans = go(idx + 1 , (10 * rem + (s[idx] - '0'))%13);
	}
	return ans;
}

signed main(){
	crap;
	cin >> s;
	n = len(s);
	mem(dp, -1);
	int ans = go(0, 0);
	cout << ans << endl;
}

Measured memory_bytes: 18512