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 <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>

//#define P 1000000007
#define P 998244353

int comp(const void *a, const void *b){return *(int*)a-*(int*)b;}
int compw(const void *a, const void *b){return (*(int*)a>*(int*)b)-(*(int*)a<*(int*)b);}
int compr(const void *a, const void *b){return *(int*)b-*(int*)a;}
int compl(const void *a, const void *b){return (*(long*)a>*(long*)b)-(*(long*)a<*(long*)b);}

uint32_t nextpint(void){ char c=getchar(); while(c<'0'||'9'<c) c=getchar(); uint_fast32_t x=0; while('0'<=c && c<='9'){ x=x*10+c-'0'; c=getchar(); } return x; }

inline int min2(const int a, const int b){return a>b?b:a;}
inline int dif2(const int a, const int b){return a>b?a-b:b-a;}

int p;
int n;
char s[200001];
 
void solve25(void){
	long ans=0;
	for(int i=0; i<n; i++){
		if(s[i]%p==0){
			ans+=i+1;
		}
	}
	printf("%ld\n", ans);
}
 
long b[200001];
 
int bs(long x){
	int l=0, r=n;
	while(l<=r){
		int m=(l+r)/2;
		if(b[m]>=x) r=m-1; else l=m+1;
	}
	return l;
}
 
void solve(void){
	int i;
	b[0]=0;
	b[1]=1;
	for(i=2; i<=n; i++){
		b[i]=b[i-1]*10%p;
	}
	for(i=1; i<=n; i++){
		b[i]*=s[n-i];
		b[i]+=b[i-1];
		b[i]%=p;
	}
	qsort(b, n+1, sizeof(long), compl);
	for(i=0; i<n&&b[i]==0; i++);
	long ans2 = i*(i-1)/2;
	long ans=0;
	for(; i<=n; i++){
		ans += bs(b[i]+1)-bs(b[i])-1;
	}
	ans/=2;
	ans+=ans2;
	printf("%ld\n", ans);
}
 
int main(void){
	scanf("%d%d%s", &n, &p, s);
	for(int i=0; i<n; i++) s[i]-='0';
	if(n==0 && s[0]==0){
		puts("1");
		return 0;
	}
	
	if(p==2 || p==5){
		solve25();
	}else{
		solve();
	}
}