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 Rust (1.15.1) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;
use std::convert::TryInto;
use std::ops::*;

// #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
// pub struct GF(pub u64, pub u64);

// impl std::fmt::Display for GF {
//     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> std::fmt::Result {
//         write!(f, "{}", self.0)
//     }
// }

// impl Echo for GF {
//     fn echo(&self, w: &mut impl std::io::Write) -> Result<(), std::io::Error> {
//         write!(w, "{}", self.0)
//     }
// }

// impl GF {
//     pub fn new<T: TryInto<i64>>(v: T, p: u64) -> Self {
//         Self(v.try_into().ok().unwrap().rem_euclid(p as i64) as u64, p)
//     }

//     pub fn pow(self, mut r: u64) -> Self {
//         let mut k = self;
//         let mut ret = GF::new(1, self.1);
//         while r > 0 {
//             if r % 2 != 0 {
//                 ret = ret * k;
//             }
//             r /= 2;
//             k = k * k;
//         }
//         ret
//     }

//     // This requires P is prime
//     pub fn recip(self) -> Self {
//         self.pow(self.1 - 2)
//     }
// }

// impl<T: Into<GF>> Add<T> for GF {
//     type Output = Self;
//     fn add(self, rhs: T) -> Self::Output {
//         Self::new(self.0 + rhs.into().0, self.1)
//     }
// }

// impl<T: Into<GF>> AddAssign<T> for GF {
//     fn add_assign(&mut self, rhs: T) {
//         *self = *self + rhs;
//     }
// }

// impl<T: Into<GF>> Sub<T> for GF {
//     type Output = Self;
//     fn sub(self, rhs: T) -> Self::Output {
//         Self::new(self.0 + self.1 - rhs.into().0, self.1)
//     }
// }

// impl<T: Into<GF>> SubAssign<T> for GF {
//     fn sub_assign(&mut self, rhs: T) {
//         *self = *self - rhs;
//     }
// }

// impl<T: Into<GF>> Mul<T> for GF {
//     type Output = Self;
//     fn mul(self, rhs: T) -> Self::Output {
//         Self::new(self.0 * rhs.into().0, self.1)
//     }
// }

// impl<T: Into<GF>> MulAssign<T> for GF {
//     fn mul_assign(&mut self, rhs: T) {
//         *self = *self * rhs;
//     }
// }

// impl<T: Into<GF>> Div<T> for GF {
//     type Output = Self;
//     fn div(self, rhs: T) -> Self::Output {
//         self * rhs.into().recip()
//     }
// }

// impl<T: Into<GF>> DivAssign<T> for GF {
//     fn div_assign(&mut self, rhs: T) {
//         *self = *self / rhs;
//     }
// }

fn char_to_int(c: char) -> u64 {
    (c as u8 - '0' as u8) as _
}

fn main() {
    input! {
        n: usize,
        p: u64,
        s: Chars,
    }

    if p == 2 {
        let mut ans = 0;
        for i in 0..n {
            if char_to_int(s[i]) % 2 == 0 {
                ans += i + 1;
            }
        }
        echo!(ans);
        return;
    }

    if p == 5 {
        let mut ans = 0;
        for i in 0..n {
            if char_to_int(s[i]) % 5 == 0 {
                ans += i + 1;
            }
        }
        echo!(ans);
        return;
    }

    // sum [i, n)
    let mut acc = vec![0; n + 1];
    let mut base = 1;
    let mut mm = BTreeMap::<u64, usize>::new();

    for i in (0..n).rev() {
        acc[i] = (acc[i + 1] + char_to_int(s[i]) * base) % p;
        *mm.entry(acc[i]).or_default() += 1;
        base = (base * 10) % p;
    }
    *mm.entry(0).or_default() += 1;

    let mut ans = 0;

    for i in (1..=n).rev() {
        *mm.entry(acc[i]).or_default() -= 1;

        ans += mm.get(&acc[i]).unwrap_or(&0);
    }

    echo!(ans);
}
*/

fn main() {
    let exe = "/tmp/binD4C0F14D";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";