#include <fstream>
#include <queue>
#include <cstring>

#define In "diviz.in"
#define Out "diviz.out"
#define Mod 30103
#define Nmax 205
#define Kmax 105

using namespace std ;
int First[Nmax][10],dp[2][Nmax][Kmax], sol;
///dp[i][j][k] = numarul de subsiruri de lungime k terminate pe pozitia i care au restul j
short a[Nmax], K, y, x ,n;
char s[Nmax];
bool Is[2][Nmax][Kmax];
queue < pair < short ,short > > Q[2];
inline void Read()
{
    ifstream f(In);
    f>>K>>x>>y>>(s+1);
    for(n = 1;s[n];++n)
        a[n] = s[n]-'0';
    --n;
    f.close();
}

inline void PreProcess()
{
    int i;
    int Last[10];
    for(i = 0;i < 10;++i)
        Last[i] = n+1;
    for(i = n; i; --i)
    {
        Last[a[i]] = i;
        memcpy(First[i],Last,sizeof(Last));
    }
}

inline void Solve()
{
    int i, j, p ,c, k, r, L;
    for(c = 1;c < 10; ++c)
        if(First[1][c] <= n)
        {
            dp[1][First[1][c]][c%K]++;
            Q[1].push(make_pair(First[1][c],c%K));
        }
    for(k = L = 1;k <= y; ++k,L ^= 1)
    {
        for(; !Q[L].empty(); Q[L].pop())
            {
                i = Q[L].front().first;
                j = Q[L].front().second;
                if(x <= k && j==0)
                {
                    sol += dp[L][i][j];
                    if(sol >= Mod)
                        sol -= Mod;
                }
                if(i<n)
                    for(c = 0;c < 10; ++c)
                    {
                        p = First[i+1][c];
                        if(p<=n)
                        {
                            r = (j*10+c)%K;
                            dp[L^1][p][r] += dp[L][i][j];
                            if(dp[L^1][p][r] >= Mod)
                                dp[L^1][p][r] -= Mod;
                            if(!Is[L^1][p][r])
                            {
                                Q[L^1].push(make_pair(p,r));
                                Is[L^1][p][r] = 1;
                            }
                        }
                    }
                Is[L][i][j] = 0;
                dp[L][i][j] = 0;
            }
    }
}

inline void Write()
{
    ofstream g(Out);
    g<<sol<<"\n";
    g.close();
}

int main()
{
    Read();
    PreProcess();
    Solve();
    Write();
    return 0;
}