#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 mem(a,b) memset(a,b,sizeof(a))
#define mpy(a,b) memcpy(a,b,sizeof(b))
#define dbg(...) cerr<<"#"<<__LINE__<<": "<<__VA_ARGS__<<endl
#define Fi(s) freopen(s,"r",stdin)
#define Fo(s) freopen(s,"w",stdout)
#define Fio(s) Fi(s".in"),Fo(s".out")
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

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*=(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
};
const int P = 998244353;
using Z = mod_int<P>;

ll qpow(ll x, ll k){
	ll ret = 1;
	while(k){
		if(k & 1) (ret *= x) %= mod;
		(x *= x) %= mod, k >>= 1;
	}
	return ret;
}

namespace Poly_space{
	Z inv2 = (P + 1) / 2;
	vector<int> rev;
	vector<Z> gg = {0, 1};
	Z rt = 3;
	void setroot(Z x){rt = x;}
	void dft(vector<Z> &a){
		int n = a.size();
		if((int)rev.size() != n){
			int k = __builtin_ctz(n) - 1; rev.resize(n);
			for(int i = 0; i < n; i++){rev[i] = rev[i >> 1] >> 1 | (i & 1 ? (1 << k) : 0);}
		}
		for(int i = 0; i < n; i++) if(i < rev[i]) swap(a[i], a[rev[i]]);
		if((int)gg.size() < n){
			int k = __builtin_ctz(gg.size()); gg.resize(n);
			while((1 << k) < n){
				Z e = rt.pow((P - 1) >> (k + 1));
				for(int i = (1 << (k - 1)); i < (1 << k); i++) gg[i << 1] = gg[i], gg[(i << 1) | 1] = gg[i] * e;
				k++;
			}
		}
		for(int mid = 1; mid < n; mid <<= 1) for(int i = 0; i < n; i += (mid << 1)) for(int j = 0; j < mid; j++){
			Z x = a[i + j], y = a[i + j + mid] * gg[mid + j];
			a[i + j] = x + y, a[i + j + mid] = x - y;
		}
	}
	void idft(vector<Z> &a){
		int n = a.size(); reverse(a.begin() + 1, a.end()), dft(a);
		Z inv = Z(1 - P) / Z(n); for(int i = 0; i < n; i++) a[i] *= inv;
	}
	struct Poly{
		vector<Z> a;
		Poly(){} Poly(const vector<Z> &x): a(x){} Poly(const initializer_list<Z> &x): a(x){}
		int size()const{return a.size();} void resize(int x){a.resize(x);}
		Z operator [](int ind)const{if(ind < 0 || ind >= size()) return 0; return a[ind];}
		Z&operator [](int ind){return a[ind];}
		Poly modxk(int k)const{k = min(k, size()); return Poly(vector<Z>(a.begin(), a.begin() + k));}
		Poly mulxk(int k)const{vector<Z> b = a; b.insert(b.begin(), k, 0); return b;}
		Poly divxk(int k)const{if(size() <= k) return Poly(); return Poly(vector<Z>(a.begin() + k, a.end()));}
		friend Poly operator + (const Poly &a, const Poly &b){
			vector<Z> ret(max(a.size(), b.size()));
			for(int i = 0; i < ret.size(); i++) ret[i] = a[i] + b[i];
			return Poly(ret);
		}
		friend Poly operator - (const Poly &a, const Poly &b){
			vector<Z> ret(max(a.size(), b.size()));
			for(int i = 0; i < ret.size(); i++) ret[i] = a[i] - b[i];
			return Poly(ret);
		}
		friend Poly operator * (const Poly &a, const Z &b){
			vector<Z> ret(a.size());
			for(int i = 0; i < ret.size(); i++) ret[i] = a[i] * b;
			return Poly(ret);
		}
		friend Poly operator * (Poly a, Poly b){
			if(a.size() == 0 || b.size() == 0) return Poly();
			int sz = 1, n = a.size() + b.size() - 1;
			while(sz < n) sz <<= 1;
			a.resize(sz), b.resize(sz), dft(a.a), dft(b.a);
			for(int i = 0; i < sz; i++) a.a[i] = a[i] * b[i];
			idft(a.a), a.resize(n); return a;
		}
		Poly inv(int deg)const{
			if(deg == 1) return Poly({a[0].pow(P - 2)});
			Poly res = inv((deg + 1) >> 1), tmp = *this;
			int sz = 1; while(sz < (deg << 1)) sz <<= 1;
			tmp = tmp.modxk(deg), tmp.resize(sz), res.resize(sz);
			dft(tmp.a), dft(res.a);
			for(int i = 0; i < sz; i++) res[i] = 2 * res[i] - res[i] * res[i] * tmp[i];
			idft(res.a), res.resize(deg);
			return res;
		}
		Poly derivative()const{
			if(size() == 1) return Poly();
			Poly ret(vector<Z>(size() - 1));
			for(int i = 1; i < size(); i++) ret.a[i - 1] = a[i] * i;
			return ret;
		}
		Poly integrate()const{
			Poly ret(vector<Z>(size() + 1));
			for(int i = 1; i < ret.size(); i++) ret.a[i] = a[i - 1] * Z(i).inv();
			return ret;
		}
		Poly ln(int deg){
			Poly res = derivative(), tmp = inv(deg);
			res = (res * tmp).integrate(), res.resize(deg);
			return res;
		}
		Poly exp(int deg){
			Poly ret(vector<Z>(1)); ret[0] = 1; int i = 1;
			while(i < deg) i <<= 1, ret = (ret * (Poly({1}) - ret.ln(i) + modxk(i))).modxk(i);
			return ret.modxk(deg);
		}
	};
}
using namespace Poly_space;

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,up;
Z fact[100005],ifac[100005],inv[100005];
int w[1 << 3];

struct M{
	Poly v[1 << 2][1 << 2];
}A,B,temp;

M mul(M a,M b,int deg){
	int N = 1;
	while(N <= 2 * (deg - 1)) N *= 2;
	M c;
	rep(S,0,up - 1){
		rep(T,0,up - 1){
			a.v[S][T].a.resize(deg);
			b.v[S][T].a.resize(deg);
			a.v[S][T].a.resize(N);
			b.v[S][T].a.resize(N);
			c.v[S][T].a.resize(N);
			dft(a.v[S][T].a);
			dft(b.v[S][T].a);
		}
	}
	rep(S,0,up - 1){
		rep(T,0,up - 1){
			rep(O,0,up - 1){
				rep(i,0,N - 1) c.v[S][T].a[i] += a.v[S][O].a[i] * b.v[O][T].a[i];
			}
			idft(c.v[S][T].a);
			c.v[S][T].a.resize(deg);
		}
	}
	return c;	
}
Poly _res[1 << 2];
void matrix_inv(int deg){
	if(deg == 1){
		rep(S,0,up - 1){
			rep(T,0,up - 1) A.v[S][T].a.resize(deg);
			A.v[S][S].a[0] = 1;
		}
		return;
	}	
	int hdeg = (deg + 1) / 2;
	matrix_inv(hdeg);
	temp = mul(A,B,deg);
	rep(S,0,up - 1){
		rep(T,0,up - 1){
			rep(i,0,deg - 1) temp.v[S][T].a[i] *= -1; 
		}
		temp.v[S][S].a[0] += 1;
		rep(T,0,up - 1) temp.v[S][T] = temp.v[S][T].divxk(hdeg);
	}
	temp = mul(temp,A,deg - hdeg);
	rep(S,0,up - 1){
		rep(T,0,up - 1){
			rep(i,0,deg - hdeg - 1) A.v[S][T].a.eb(temp.v[S][T].a[i]);
		}
	}
}

void slv(){
/*	printf("try calc inv:\n");
	rep(S,0,up - 1){
		rep(T,0,up - 1){
			printf("M[%d][%d]\n",S,T);
			rep(i,0,n) printf("%d ",B.v[S][T].a[i].val());
			printf("\n");
		}
	}*/
	matrix_inv(n);
	rep(S,0,up - 1){
		rep(T,0,up - 1) _res[S] = _res[S] + A.v[S][T];
	}
}

Z dp[4],ndp[4];
void trans(int p,int op){
	rep(S,0,up - 1){
		int msk = (S << 1) | p;
		ndp[msk % (1 << (k - 2))] += dp[S] * w[msk] * op;
	}
}

void strans(int p,int op){
	rep(S,0,up - 1){
		int msk = (S << 1) | p;
		ndp[msk % (1 << (k - 2))] += dp[S] * op;
	}	
}

void tem(){
	rep(S,0,up - 1){
		dp[S] = ndp[S];
		ndp[S] = 0;
//		rep(i,0,k - 3) printf("%d",(S >> i) & 1);
//		printf("->%d\n",dp[S].val());
	}
//	printf("\n");
}

int main(){
//	freopen("test.in","r",stdin);
	scanf("%d%d",&n,&k);
	up = (1 << (k - 2));
	rep(S,0,(1 << (k - 1))) scanf("%d",&w[S]);
	fact[0] = 1;
	rep(i,1,n) fact[i] = fact[i - 1] * i;
	ifac[n] = Z(1) / fact[n];
	per(i,n - 1,0) ifac[i] = ifac[i + 1] * (i + 1);
	rep(i,1,n) inv[i] = ifac[i] * fact[i - 1];

	rep(S,0,up - 1){
		rep(T,0,up - 1) B.v[S][T].a.resize(n + 1);
		B.v[S][S].a[0] += 1;
	}
	rep(S,0,up - 1){
		fill(dp,dp + up,0);
		dp[S] = 1;
		rep(i,1,n){
			if(i == 1){
				trans(0,1);
			}else{
				trans(0,-1);
				trans(1,1);
			}
//			printf("i=%d\n",i);
			tem();
			rep(T,0,up - 1) B.v[S][T].a[i] -= dp[T] * ifac[i];
		}
	}
	slv();
	Z answer = 0;
	rep(SS,0,up - 1){
		fill(dp,dp + up,0);
		dp[0] = 1;
		int len = 1;
		Z cof = 1;
		rep(i,0,k - 3){
			if((SS >> i) & 1){
				strans(0,-1);
				strans(1,1);
				cof *= inv[++len];
			}else{
				strans(0,1);
				len = 1;
			}
			tem();
		}
		rep(i,0,(n - 1) - (k - 2)){
			rep(S,0,up - 1) answer += cof * dp[S] * _res[S].a[(n - 1) - (k - 2 + i)];
			trans(0,-1);
			trans(1,1);
			tem();
			cof *= inv[++len];
		}
	}
	answer *= fact[n];
	printf("%d\n",answer.val());
	cerr << clock() << endl;
	return 0;
}