Problem:
Score : 500 points

Problem Statement

Takahashi has a string S of length N consisting of digits from 0 through 9.

He loves the prime number P. He wants to know how many non-empty (contiguous) substrings of S - there are N \times (N + 1) / 2 of them - are divisible by P when regarded as integers written in base ten.

Here substrings starting with a 0 also count, and substrings originated from different positions in S are distinguished, even if they are equal as strings or integers.

Compute this count to help Takahashi.

Constraints

1 \leq N \leq 2 \times 10^5

S consists of digits.

|S| = N

2 \leq P \leq 10000

P is a prime number.

Input

Input is given from Standard Input in the following format:

N P
S

Output

Print the number of non-empty (contiguous) substrings of S that are divisible by P when regarded as an integer written in base ten.

Sample Input 1

4 3
3543

Sample Output 1

6

Here S = 3543. There are ten non-empty (contiguous) substrings of S:

3: divisible by 3.

35: not divisible by 3.

354: divisible by 3.

3543: divisible by 3.

5: not divisible by 3.

54: divisible by 3.

543: divisible by 3.

4: not divisible by 3.

43: not divisible by 3.

3: divisible by 3.

Six of these are divisible by 3, so print 6.

Sample Input 2

4 2
2020

Sample Output 2

10

Here S = 2020. There are ten non-empty (contiguous) substrings of S, all of which are divisible by 2, so print 10.

Note that substrings beginning with a 0 also count.

Sample Input 3

20 11
33883322005544116655

Sample Output 3

68

Solution in C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h> // int64_t

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) > (b) ? (b) : (a))

int get_int2(int *a1, int *a2) {
  scanf("%d %d", a1, a2);
  return 0;
}


int get_str(char *str, int size)
{
    char format[100];
    if (size == 0)
        return 0;
    snprintf(format, sizeof(format), "%%%ds", size);
    scanf(format, str);
    return 0;
}

#define NUM_MAX 200000
#define BUF_SIZE (NUM_MAX+50)
#define PRIME_MAX 10000

int main(void) {
    int num, divisor;
    get_int2(&num, &divisor);

    static char str[BUF_SIZE];
    static int mod_map[PRIME_MAX];
    get_str(str, BUF_SIZE);
    int i;

    int64_t ans = 0;
    if(divisor == 2 || divisor == 5) {
        for(i = num-1; i >= 0; i--) {
            if(!(str[i]%divisor)) {
                ans += (i+1);
            }
        }
        goto finish;
    }
    
    // divisor has nothing to do with 10**n.
    int sum = 0;
    int power10 = 1;
    mod_map[0]++;
    for(i = num-1; i >= 0; i--) {
        int d = str[i] - '0';
        sum = (d*power10+sum)%divisor;
        power10 = (power10*10)%divisor;
        mod_map[sum]++;
    }
    int offset = 0;
    // ans += mod_map[offset];
#ifdef DEBUG
    printf("ans: %lld\n", ans);
#endif
    power10 = 1;
//     for(i = num-1; i >= 0; i--) {
//         int d = str[i] - '0';
//         offset = (d*power10+offset)%divisor;
//         power10 = (power10*10)%divisor;
//         mod_map[offset]--;
//         ans += mod_map[offset];
// #ifdef DEBUG
//         printf("ans: %d\n", mod_map[offset]);
// #endif
//     }
    for(i = 0; i < divisor; i++) {
        ans += (int64_t)mod_map[i] * (mod_map[i]-1)/2;
    }
finish:
    printf("%lld\n", ans);
    return 0;
}