#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,m;
bitset <2005> w[2005],cur,X;
char str[2005];

void ins(){
    rep(i,1,m){
        if(!cur.test(i)) continue;
        if(!w[i].test(i)){
            w[i] = cur;
            return;
        }
        cur ^= w[i];
    }
    printf("0\n");
    exit(0);
}

void add(int p){
//    printf("add %d\n",p);
    while(X.test(p)){
        X.reset(p);
        p++;
    }
    X.set(p);
}
Z val[2005],qfact[2005],qifac[2005],P[2005];
void init(){
    P[0] = 1;
    rep(i,1,n) P[i] = P[i - 1] + P[i - 1];
    qfact[0] = 1;
    rep(i,1,n) qfact[i] = qfact[i - 1] * (P[i] - 1);
    qifac[n] = Z(1) / qfact[n];
    per(i,n - 1,0) qifac[i] = qifac[i + 1] * (P[i + 1] - 1);
/*    rep(i,1,n) printf("%d ",qfact[i].val());
    printf("\n");
    rep(i,1,n) printf("%d ",qifac[i].val());
    printf("\n");*/
}

Z C2(int N,int M){
    if(N < M || M < 0) return 0;
    return qfact[N] * qifac[M] * qifac[N - M];
}

const Z i2 = Z(1) / 2;
Z res[2005],dp[2][2005],ndp[2][2005];
void solve(){
    dp[0][0] = dp[1][0] = 1;
    rep(i,1,n){
        if(!X.test(i)){
            //10 pattern
            rep(j,0,i - 1){
                ndp[0][j] += C2(i - 1,j) * i2;
            }            

            rep(j,0,i - 1){
                //这一位上有
                ndp[0][j + 1] += dp[0][j] * P[i - 1 - j];
                ndp[1][j + 1] += dp[0][j] * P[i - 1 - j];

                //这一位上没有
                ndp[0][j] += dp[0][j] * i2;
                ndp[1][j] += dp[1][j];
            }
        }else{
            //01 pattern
            rep(j,0,i - 1){
                ndp[0][j] += C2(i - 1,j) * i2 * val[j];
                ndp[1][j] += C2(i - 1,j) * val[j];
            }

            rep(j,0,i - 1){
                //这一位上有
                ndp[0][j + 1] += dp[0][j] * P[i - 1 - j] * val[j];
                ndp[1][j + 1] += dp[0][j] * P[i - 1 - j] * val[j];

                //这一位上没有
                ndp[0][j] += dp[0][j] * i2;
            }
        }
//        printf("i=%d\n",i);
        rep(j,0,i){
            dp[0][j] = ndp[0][j];
            dp[1][j] = ndp[1][j];
            ndp[0][j] = ndp[1][j] = 0;
//            printf("[0]%d [1]%d\n",dp[0][j].val(),dp[1][j].val());
        }
    }
    rep(i,0,n) res[i] = dp[1][i];
//    rep(i,0,n) printf("%d ",res[i].val());
//    printf("\n");
}

int main(){
//    freopen("test.in","r",stdin);
    scanf("%d%d",&n,&m);
    init();
    rep(i,1,n){
        scanf("%s",str + 1);
        cur.reset();
        rep(j,1,m) if(str[j] == '1') cur.set(j);
        ins();
    }
    ll prd = 1;
    rep(i,0,n){
        val[i] = power(2,prd);
        prd = prd * 2 % (mod - 1);
    }
    scanf("%s",str + 1);
/*    rep(i,1,m){
        rep(j,1,m) printf("%d",w[i].test(j));
        printf("\n");
    }*/
    cur.reset();
    int ssum = n;
    rep(i,1,m){
        if(str[i] == '1' && w[i].test(i)) add(ssum);

        if(cur.test(i) + '0' != str[i]){
            if(w[i].test(i)){
                cur ^= w[i];    
            }else{
                if(!cur.test(i)) add(ssum + 1);
                break;                
            }
        }
        ssum -= w[i].test(i);
        if(i == m) add(1);
    }
//    rep(i,1,n + 1) printf("%d",X.test(i));
//    printf("\n");
    //现在是 1~n 位,但一个 special case 是只有 n+1 位有值,此时相当于问 [0,2^n-1] 取一个子集满秩方案数
    if(X.test(n + 1)) rep(d,0,n) res[d] = C2(n,d) * val[d];
    else solve();
//    rep(d,0,n) printf("%d ",res[d].val());
//    printf("\n");
    rep(i,0,n){
        rep(j,0,i - 1) res[i] -= C2(n - j,i - j) * res[j];
    }
//    rep(i,0,n) printf("%d ",res[i].val());
//    printf("\n");
    printf("%d\n",(res[n] / 2).val());
	return 0;
}
/*
00
01
10 选一个子集出来,满秩方案数
*/