#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<string>
#include<cstring>
#include<algorithm>
#include<sstream>
#include<complex>
#include<functional>
#include<vector>
#include<map>
#include<queue>
#include<deque>
#include<stack>
#include<set>

using namespace std;
#define endl '\n'

using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;

template<typename T = long long>
T gcd(T a, T b) { return b ? gcd(b, a%b) : a; }

/* 拡張ユークリッドの互除法(ax + by = 1 を満たすx, y) */
template<typename T>
T extgcd(T a, T b, T& x, T& y) {
	T d = a;
	if (b != 0) {
		d = extgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
	else {
		x = 1; y = 0;
	}
	return d;
}

/* MODを法とする環 */
template<typename T, T MOD = 1000000007>
struct Mint {

	static constexpr T mod = MOD;

	T v;

	/* コンストラクタ群 */
	Mint() :v(0) {}

	Mint(signed _v) :v(_v) {}

	Mint(long long t) {
		v = t % mod;
		if (v < 0) v += mod;
	}

	/* べき乗を計算 */
	Mint pow(long long k) {
		Mint res(1), tmp(v);
		while (k) {
			if (k & 1) res *= tmp;
			tmp *= tmp;
			k >>= 1;
		}
		return res;
	}

	/* 単位元 */
	static Mint add_identity() { return Mint(0); }
	static Mint mul_identyty() { return Mint(1); }

	/* 逆元を求める */
	// オイラーの定理
	Mint inv() { return pow(mod - 2); }

	// 拡張ユークリッド互除法
	Mint inv_euclid() {
		T x, y;
		extgcd(v, mod, x, y);
		return Mint(x);
	}

	/* 演算子群 */
	Mint& operator+=(Mint a) {
		v += a.v;
		if (v >= mod) v -= mod;
		return *this;
	}

	Mint& operator-=(Mint a) {
		v += mod - a.v;
		if (v >= mod) v -= mod;
		return *this;
	}

	Mint& operator*=(Mint a) {
		v = 1LL * v * a.v % mod;
		return *this;
	}

	Mint& operator/=(Mint a) {
		return (*this) *= a.inv();
		// ユークリッドの互除法を使う場合
		// return (*this) *= a.inv_euclid();
	}

	Mint& operator+=(T a) { return (*this) += Mint(a); }
	Mint& operator-=(T a) { return (*this) -= Mint(a); }
	Mint& operator*=(T a) { return (*this) *= Mint(a); }
	Mint& operator/=(T a) { return (*this) /= Mint(a); }

	Mint operator+(Mint a) const { return Mint(v) += a; }
	Mint operator-(Mint a) const { return Mint(v) -= a; }
	Mint operator*(Mint a) const { return Mint(v) *= a; }
	Mint operator/(Mint a) const { return Mint(v) /= a; }

	Mint operator+(T a) const { return Mint(v) += a; }
	Mint operator-(T a) const { return Mint(v) -= a; }
	Mint operator*(T a) const { return Mint(v) *= a; }
	Mint operator/(T a) const { return Mint(v) /= a; }

	Mint operator-() const { return v ? Mint(mod - v) : Mint(v); }

	bool operator==(const Mint a) const { return v == a.v; }

	bool operator!=(const Mint a) const { return v != a.v; }

	bool operator<(const Mint a) const { return v < a.v; }

	bool operator>(const Mint a) const { return v > a.v; }

	/* 組み合わせ */
	static Mint comb(long long n, int k) {
		Mint num(1), dom(1);
		for (int i = 0; i < k; i++) {
			num *= Mint(n - i);
			dom *= Mint(i + 1);
		}
		return num / dom;
	}

};

template<typename T, T MOD> constexpr T Mint<T, MOD>::mod;

/* ostreamで出力できるように */
template<typename T, T MOD>
ostream& operator<<(ostream &os, Mint<T, MOD> m) { os << m.v; return os; }

// value
string S;

Mint<ll> dp[100010][13];

void solve() {

	cin >> S;

	dp[0][0] = 1;

	for (int i = 0; i < S.size(); i++) {

		for (int j = 0; j < 10; j++) {
			if (S[i] == '?' || S[i] - '0' == j) {
				for (int k = 0; k < 13; k++) {
					dp[i + 1][(k * 10 + j) % 13] += dp[i][k];
				}
			}
		}

	}

	cout << dp[S.size()][5];

	return;

}

int main() {

	cin.tie(0);
	ios::sync_with_stdio(false);

	solve();

	return 0;

}


Measured memory_bytes: 10624