// ayy
// ' lamo
// SUBLIME HAX
	#include <bits/stdc++.h>
	using namespace std;
	template<class T,class U>
	ostream &operator<<(ostream &os,const pair<T,U> &x) {
		return os<<"("<<x.first<<","<<x.second<<")";
	}
	namespace dbg_ns {
		template<typename C>
		struct is_iterable {
			template<class T> static long check(...);
			template<class T> static char check(int,
				typename T::const_iterator = C().end());
			enum {
				value = sizeof(check<C>(0)) == sizeof(char),
				neg_value = sizeof(check<C>(0)) != sizeof(char)
			};
		};
		template<class T> ostream &_out_str(ostream &os,const T &x) {
			return os<<'"'<<x<<'"';
		}
		template<class T> ostream &_dbg2_5(ostream &,const T &);
		template<bool B,typename T=void> using eit=typename enable_if<B,T>::type;
		template<class T>
		inline ostream &_dbg3(ostream &os,eit<is_iterable<T>::neg_value,const T> &x) {
			return os<<x;
		}
		template<class T>
		inline ostream &_dbg3(ostream &os,eit<is_iterable<T>::value,const T> &V) {
			os<<"{";
			bool ff=0;
			for(const auto &E:V) _dbg2_5(ff?os<<",":os,E), ff=1;
			return os<<"}";
		}
		template<>
		inline ostream &_dbg3<string>(ostream &os,const string &x) {
			return _out_str(os,x);
		}
		template<>
		inline ostream &_dbg3<const char *>(ostream &os,const char *const &x) {
			return _out_str(os,x);
		}
		template<class T> inline ostream &_dbg2_5(ostream &os,const T &x) {
			return _dbg3<T>(os,x);
		}
		template<class T,typename... Args> ostream &_dbg2(ostream &os,vector<string>::iterator nm,const T &x,Args&&... args);
		inline ostream &_dbg2(ostream &os,vector<string>::iterator) { return os; }
		template<typename... Args>
		inline ostream &_dbg2(ostream &os,vector<string>::iterator nm,const char *x,Args&&... args) {
			return _dbg2(_dbg3<const char *>(os<<"  ",x),nm+1,args...);
		}
		template<class T,typename... Args>
		inline ostream &_dbg2(ostream &os,vector<string>::iterator nm,const T &x,Args&&... args) {
			return _dbg2(_dbg3<T>(os<<"  "<<*nm<<"=",x),nm+1,args...);
		}
		vector<string> split(string s) {
			vector<string> Z;
			string z="";
			s+=',';
			int dep=0;
			for(char c:s) {
				if(c==',' && !dep) Z.push_back(z),z="";
				else z+=c;
				if(c=='(') ++dep;
				if(c==')') --dep;
			}
			return Z;
		}
		template<typename... Args> inline ostream &_dbg1(int ln,const string &nm,Args&&... args) {
			auto nms=split(nm);
			return _dbg2(cerr<<"L"<<ln<<":",nms.begin(),args...)<<endl;
		}
	}
	#define dbg(...) dbg_ns::_dbg1(__LINE__,#__VA_ARGS__,__VA_ARGS__)
	#define sz(x) (int(x.size()))
	#define eprintf(...) fprintf(stderr,__VA_ARGS__)
	#define fi first
	#define se second
	#define pb push_back
// END SUBLIME HAX
// #include <bits/extc++.h>
// using namespace __gnu_pbds;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld; //CARE
typedef complex<ld> pt;
const ld eps=(ld)1e-8;
const ld tau=2*(ld)acosl(-1);
const int inf=1e9+99;
const ll linf=1e18+99;
// const int P=1e9+7;




const int N=4096;
// const int N=12;
int n;
typedef bitset<N> BS;
BS X,A[6],Y,Q;
void read(BS &bs) {
	string s; cin>>s;
	reverse(s.begin(),s.end());
	for(int i=0;i<sz(s);i++) bs[i]=int(s[i]=='1');
}
bool operator<(const BS &L,const BS &R) {
	for(int i=N;--i>=0;) if(L[i]!=R[i]) return L[i]<R[i];
	return 0;
}
int len(const BS &bs) {
	for(int i=N;--i>=0;) if(bs[i]) return i+1;
	return 0;
}

int h[6];
void rref() {
	for(int i=0;i<n;i++) h[i]=len(A[i])-1;
	for(;;) {
		for(int i=0;i<n;i++) for(int j=0;j<n;j++) if(h[i]>=h[j]) {
			if(A[i] != A[j]<<(h[i]-h[j])) {
				A[i] ^= A[j]<<(h[i]-h[j]);
				h[i]=len(A[i])-1;
				goto win;
			}
		}
		break;
		win:;
	}
	Q=A[min_element(h,h+n)-h];
}



const int P=998244353;
int powq(int x,int e) {
	if(!e) return 1;
	if(e&1) return int(1LL*x*powq(x,e-1)%P);
	x=powq(x,e>>1);
	return int(1LL*x*x%P);
}


int32_t main() {
	cin>>n;
	read(X);
	for(int i=0;i<n;i++) read(A[i]);
	rref();
	// dbg(Q);

	int w=len(Q); assert(w>0);
	int m=len(X); assert(m>0);
	Y.reset();
	if(w>m) return cout<<1<<endl,0;
	ll Z=0;
	for(int i=m-1;i>=w-1;i--) {
		// dbg(i,X,Y,i-(w-1));
		if(X[i]) Z+=powq(2,i-(w-1));
		if(X[i] != Y[i]) Y^=Q<<(i-(w-1));
	}
	if(!(X<Y)) ++Z;
	cout<<Z%P<<endl;
}











