#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,k,m,sz;
char str[120];

Z f[1 << 20],g[1 << 20];
void solve1(){
    int sour = 0;
    rep(i,1,m) if(str[i] == '1') sour |= 1 << (m - i);

    int msk = (1 << (k - 1)) - 1;
    g[sour] = 1;
    rep(i,m + 1,n){
        rep(S,0,msk){
            if(i < k || popcnt(S) != k / 2 - 1) f[((S << 1) | 1) & msk] += g[S];
            if(i < k || popcnt(S) != k / 2) f[(S << 1) & msk] += g[S];
        }
        rep(S,0,msk){
            g[S] = f[S];
            f[S] = 0;
//            if(g[S].val()) printf("%d %d\n",S,g[S].val());
        }
    }
    Z answer = 0;
    rep(S,0,msk) answer += g[S];
    printf("%d\n",answer.val());
}

Z dp[125][125],val[125][125][125],sval[125][125],tval[125][125],sp[125];
int ban[125][125],frp[125][125][125];
int ssum;
void calc(int sn,int sx,int sy,int tp){
    if(frp[sn][sx][sy]) return;
    frp[sn][sx][sy] = 1;
    int lim = sn - (sz + 1) * k / 2 + n;
    rep(i,0,k) fill(dp[i],dp[i] + n + 1,0);
    dp[sx][sy] = 1;
/*    printf("calc sn=%d (%d,%d) lim=%d\n",sn,sx,sy,lim);
    per(j,n,0){
        rep(i,0,k) printf("%d ",ban[i][j] | (i > n % k && j <= lim));
        printf("\n");
    }*/
    rep(i,1,k){
        rep(j,1,n){
            if(ban[i][j] || (i > n % k && j <= lim)) continue;
            dp[i][j] += dp[i - 1][j - 1] + dp[i - 1][j];
        }
    }

    if(tp){
        rep(i,1,n) tval[sn][i] = dp[k][i];
        sp[sn] = dp[n % k][lim];
    }else{
        rep(i,1,n) val[sn][sy][i] = dp[k][i];
        sval[sn][sy] = dp[n % k][lim];
    }
/*    printf("dpval:\n");
    per(j,n,0){
        rep(i,0,k) printf("%d ",dp[i][j].val());
        printf("\n");
    }*/
}

Z countpath(int sn,int sour,int tem){
    if(sour == -1){
        calc(sn,m,ssum - k / 2 + n,1);
        if(tem == -1) return sp[sn];
        return tval[sn][tem];
    }else{
        calc(sn,0,sour,0);
        if(tem == -1) return sval[sn][sour];
        return val[sn][sour][tem];
    }
}

/*Z countpath(int sn,int sour,int tem){
    Z ret = ccountpath(sn,sour,tem);
    printf("count path %d %d %d ret=%d\n",sn,sour,tem,ret.val());
    return ret;
}*/

int a[120],s[120];
Z answer;
Z M[25][25];
Z det(int N){
/*    printf("matrix:\n");
    rep(i,1,N){
        rep(j,1,N) printf("%d ",M[i][j].val());
        printf("\n");
    }*/
    Z ret = 1;
    rep(j,1,N){
        int pos = -1;
        rep(i,j,N) if(M[i][j].val()) pos = i;
        if(pos == -1) return 0;
        if(pos != j){
            ret *= -1;
            rep(_k,1,N) swap(M[j][_k],M[pos][_k]);
        }
        Z iv = Z(1) / M[j][j];
        rep(i,j + 1,N){
            Z rr = M[i][j] * iv;
            rep(_k,1,N) M[i][_k] -= M[j][_k] * rr;
        }
    }
    rep(i,1,N) ret *= M[i][i];
    return ret;
}

void calc(){
    if(a[1] < ssum) return;
    rep(i,1,sz) s[i] = s[i - 1] + a[i];

//    printf("calc\n");
    rep(d,0,min(n % k,k / 2 - 1)){
//        rep(i,1,sz) printf("%d ",s[i]);
        int sn = s[sz] + d;
//        printf(" with sn=%d\n",sn);
        rep(i,2,sz + 1){
            rep(j,1,sz) M[i][j] = countpath(sn,s[i - 1] - i * k / 2 + n,s[j] - j * k / 2 + n);
        }
        rep(j,1,sz) M[1][j] = countpath(sn,-1,s[j] - j * k / 2 + n);
        rep(i,2,sz + 1) M[i][sz + 1] = countpath(sn,s[i - 1] - i * k / 2 + n,-1);
        M[1][sz + 1] = countpath(sn,-1,-1);
        answer += det(sz + 1);
    }
}

void dfs(int p){
    if(p == sz + 1){
        calc();
        return;
    }
    rep(i,0,k / 2 - 1){
        a[p] = i;
        dfs(p + 1);
    }
}

void solve2(){
    memset(ban,0,sizeof(ban));
    ssum = 0;
    rep(i,0,m){
        if(i) ssum += str[i] - '0';
        if(ssum >= k / 2) return;
        ban[i][ssum - k / 2 + n] = 1;
    }
    dfs(1);
}

int main(){
//    freopen("test.in","r",stdin);
    scanf("%d%d%d",&n,&k,&m);
    scanf("%s",str + 1);
    if(k <= 20){
        solve1();
        return 0;
    }
    sz = n / k;
    solve2();
    rep(i,1,m){
        if(str[i] == '0') str[i] = '1';
        else str[i] = '0';
    }
    memset(frp,0,sizeof(frp));
    solve2();
    printf("%d\n",answer.val());
	return 0;
}