#include <bits/stdc++.h>
#define NMAX (int)(54)
#define MKMAX 130
#define mod (int)(1e9+7)
#define all(x) x.begin(),x.end()
#define rep(i, l, r) for(int i = l; i < r; ++i)
#define rev(i, r, l) for(int i = r - 1; i >= l; --i)
#define ft first
#define sd second
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
struct matrix{
    ll mat[MKMAX][MKMAX],n;
    ll *operator[](const int p){
        return mat[p];
    }
    matrix operator*(const matrix& oth){
        matrix sol;
        sol.n=n;
        rep(i, 0, n)
            rep(j, 0, n)
                rep(k, 0, n)
                    sol[i][j]=(sol[i][j] + mat[i][k] * oth.mat[k][j])%mod;
        return sol;
    }
    void I(){
        rep(i, 0, n)
            mat[i][i]=1;
    }
    matrix(){
        memset(mat, 0, sizeof mat);
        n=0;
    }
};

int n,k,sz,ans,cntBit[MKMAX];
int dp[NMAX][MKMAX];/*dp[i][j] = how many sets of type  j
                             are there after traversing the prefix of length i*/
int good[MKMAX][MKMAX][2],trans[MKMAX][MKMAX];
string s;

vector <int> part; //all partitions with an even number of bits
vector <int> poss; //all possible states that we can reach from our mask

inline bool bit(int,int);
void precalc();
matrix expLog(matrix,int);

int main(){
    cin>>n>>k;
    cin>>s;
    s=" " + s;
    sz=s.size();
    precalc();
    rep(msk, 0, (1<<n)){//what states do we reach from msk after traversing s
        memset(dp, 0, sizeof dp);
        poss.clear();
        rep(t, 0, (1<<n))
            if((t & msk) == msk)
                poss.pb(t);
        int temp;
        dp[0][msk]=1;
        rep(i, 1, sz)
            for(auto t:poss)
                for(auto ad:part){
                    if(good[t][ad][s[i]-'0'] == -1) continue;
                    temp=good[t][ad][s[i]-'0'];
                    dp[i][temp]=(dp[i][temp] + dp[i-1][t])%mod;
                }
        for(auto t:poss)
            trans[msk][t]=dp[sz-1][t];
    }
    matrix T;
    T.n=(1<<n);
    rep(i, 0, T.n)
        rep(j, 0, T.n)
            T[i][j]=trans[i][j];
    T=expLog(T, k);
    cout<<T[0][(1<<n)-1];
    return 0;
}
void precalc(){
    part.pb(0);
    rep(msk, 1, (1<<n)){
        cntBit[msk]=cntBit[msk&(msk-1)]+1;
        if(!(cntBit[msk]&1))//so their xor is zero
            part.pb(msk);
    }
    bool ok;
    int temp;
    rep(msk, 0, (1<<n))
        for(auto ad:part){
            ok=1;
            rep(i, 0, n-1)
                if(bit(ad, i) && !bit(msk, i) && !bit(ad,i+1)){
                    ok=0;
                    break;
                }

            if(ok){
                temp=msk;
                rep(i, 0, n-1)
                    if(!bit(msk, i) && !bit(ad, i) && bit(ad, i+1))
                        temp|=(1<<i);

                good[msk][ad][0]=temp;
                if(!bit(ad, n-1))
                    temp|=(1<<(n-1));
                good[msk][ad][1]=temp;
            }else
                good[msk][ad][0]=good[msk][ad][1]=-1;
            if(bit(ad, n-1) && !bit(msk, n-1))
                good[msk][ad][0]=-1;
        }

}
matrix expLog(matrix x,int k){
    matrix sol;
    sol.n=(1<<n);
    sol.I();
    for(;k;k>>=1){
        if(k&1)
            sol=sol*x;
        x=x*x;
    }
    return sol;
}
inline bool bit(int x,int k){
    return x & (1<<k);
}