Problem:
Score : 400 points

Problem Statement

Given is a string S. Each character in S is either a digit (0, ..., 9) or ?.

Among the integers obtained by replacing each occurrence of ? with a digit, how many have a remainder of 5 when divided by 13? An integer may begin with 0.

Since the answer can be enormous, print the count modulo 10^9+7.

Constraints

S is a string consisting of digits (0, ..., 9) and ?.

1 \leq |S| \leq 10^5

Input

Input is given from Standard Input in the following format:

S

Output

Print the number of integers satisfying the condition, modulo 10^9+7.

Sample Input 1

??2??5

Sample Output 1

768

For example, 482305, 002865, and 972665 satisfy the condition.

Sample Input 2

?44

Sample Output 2

1

Only 044 satisfies the condition.

Sample Input 3

7?4

Sample Output 3

0

We may not be able to produce an integer satisfying the condition.

Sample Input 4

?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???

Sample Output 4

153716888

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public class ABC
{
    //          long[] sp = Console.ReadLine().Split().Select(long .Parse).ToArray();
    //          int[] sp = Console.ReadLine().Split().Select(int.Parse).ToArray();
    public static void Main()
    {
        string s = Console.ReadLine();
        int N = s.Length;
        long[,] dp = new long[13,N+1];

        int[] addResidue = new int[13];
        addResidue[0] = 1;
        for (int i = 1; i < 13; i++)
        {
            addResidue[i] = (addResidue[i - 1] * 10) % 13;
        }
        string firsttargetValue = s[N - 1].ToString();
        if (firsttargetValue != "?")
        {
            int firstvalue = int.Parse(firsttargetValue);
            dp[firstvalue, 1] = 1;

        }
        else
        {
            for (int target = 0; target < 10; target++)
            {
                dp[target, 1] = 1;
            }

        }


        for (int i = 2; i < N+1; i++)
        {
            string targetValue = s[N - i].ToString();
            if (targetValue != "?")
            {
                int target = int.Parse(targetValue);
                //10^i * target を　足すときの　あまりへの影響は (addresidue[i%13] * target)%13を足すのと同じ
                int effect = (addResidue[(i - 1) % 6] * target) % 13;
                for (int dp_nextresidue = 0; dp_nextresidue < 13; dp_nextresidue++)
                {
                    dp[dp_nextresidue, i] += dp[(dp_nextresidue - effect + 13) % 13, i - 1];
                }

            }
            else
            {
                for (int target = 0; target < 10; target++)
                {
                    int effect = (addResidue[(i - 1) % 6] * target) % 13;
                    for (int dp_nextresidue = 0; dp_nextresidue < 13; dp_nextresidue++)
                    {
                        dp[dp_nextresidue, i] += dp[(dp_nextresidue - effect + 13) % 13, i - 1];
                        if (dp[dp_nextresidue, i] > Util.M)
                        {
                            dp[dp_nextresidue, i] %= Util.M;
                        }
                    }
                }

            }
        }


        Console.WriteLine(dp[5, N]);
    }


}








class Util
{
    public static long GCD(long a, long b)
    {
        if (a < b)
            swap(ref a, ref b);
        if (a % b == 0) return b;
        return GCD(b, a % b);

    }
    public static int GCD(int a, int b)
    {
        if (a < b)
            swap(ref a, ref b);
        if (a % b == 0) return b;
        return GCD(b, a % b);
    }

    public static void swap<T>(ref T a, ref T b)
    {
        T temp = b;
        b = a;
        a = temp;

    }
    public static long LCM(long a, long b)
    {
        return a * b / GCD(a, b);
    }
    public static long LCM(int a, int b)
    {
        return Math.BigMul(a, b) / GCD(a, b);
    }


    public static int M = (int)(Math.Pow(10,9))+7;
    private static int[] factorial_modM;
    public static int Multiple_modM(int a, int b)
    {
        return (int)(Math.BigMul(a, b) % M);
    }
    public static void factorial_modM_Prepare(int n)
    {
        factorial_modM = new int[n + 1];
        factorial_modM[0] = 1;
        for (int i = 1; i <= n; ++i)
        {
            factorial_modM[i] = Multiple_modM(factorial_modM[i - 1], i);
        }
    }
    public static int Factorial(int n)
    {
        return factorial_modM[n];
    }
    public static int Pow(int a, int m)
    {
        switch (m)
        {
            case 0:
                return 1;
            case 1:
                return a;
            default:
                int p1 = Pow(a, m / 2);
                int p2 = Multiple_modM(p1, p1);
                return ((m % 2) == 0) ? p2 : Multiple_modM(p2, a);
        }
    }
    public static int Div(int a, int b)
    {
        return Multiple_modM(a, Pow(b, M - 2));
    }
    public static int nCr_modM(int n, int r)
    {
        if (n < r) { return 0; }
        if (n == r) { return 1; }
        int res = Factorial(n);
        res = Div(res, Factorial(r));
        res = Div(res, Factorial(n - r));
        return res;
    }

}

class UnionFind<T>
{
    public int tree_height;
    public UnionFind<T> parent;
    public T item
    {
        get;
        private set;
    }

    public UnionFind(T item)
    {
        tree_height = 0;
        parent = this;
    }

    public UnionFind<T> FindAdam()
    {
        if (parent == this) return this;
        else
        {
            UnionFind<T> ParentOfParent = parent.FindAdam();
            parent = ParentOfParent;//縦長な構成をつなぎ直している
            return ParentOfParent;
        }
    }
    public static void Unite(UnionFind<T> a, UnionFind<T> b)
    {
        UnionFind<T> ParentOfA = a.FindAdam();
        UnionFind<T> ParentOfB = b.FindAdam();
        if (ParentOfA.tree_height < ParentOfB.tree_height)
        {
            ParentOfA.parent = ParentOfB;
            ParentOfB.tree_height = Math.Max(ParentOfA.tree_height + 1, ParentOfB.tree_height);
        }
        else
        {
            ParentOfB.parent = ParentOfA;
            ParentOfA.tree_height = Math.Max(ParentOfB.tree_height + 1, ParentOfA.tree_height);
        }

    }

}

static class Permutation<T>
{
    private static void Search(List<T[]> perms, Stack<T> stack, T[] a)
    {
        int N = a.Length;
        if (N == 0)
        {
            perms.Add(stack.Reverse().ToArray());
        }
        else
        {
            var b = new T[N - 1];
            Array.Copy(a, 1, b, 0, N - 1);
            for (int i = 0; i < a.Length; ++i)
            {
                stack.Push(a[i]);
                Search(perms, stack, b);
                if (i < b.Length) { b[i] = a[i]; }
                stack.Pop();
            }
        }
    }
    public static IEnumerable<T[]> All(IEnumerable<T> src)
    {
        var perms = new List<T[]>();
        Search(perms, new Stack<T>(), src.ToArray());
        return perms;
    }
}