#include<bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#include"debug.h"
#else
#define debug(...) void()
#endif
#define all(x) (x).begin(),(x).end()
template<class T>
auto ary(T *a,int l,int r){
	return vector<T>{a+l,a+1+r};
}
using ll=long long;
using ull=unsigned long long;
int mod=998244353,base;
using comp=complex<double>;
struct fastmod {
  typedef unsigned long long u64;
  typedef __uint128_t u128;

  int m;
  u64 b;

  fastmod(int m) : m(m), b(((u128)1 << 64) / m) {}
  int reduce(u64 a) {
    u64 q = ((u128)a * b) >> 64;
    int r = a - q * m;
    return r < m ? r : r - m;
  }
} Fast(2);
namespace Poly{
	const double pi=acos(-1);
	const int N=1<<20;
	int lim,rev[N];
	comp a0[N],a1[N],b0[N],b1[N],c0[N],c1[N],c2[N],pw[N];
	void Init(){
		for(int len=1;len<N;len<<=1){
			for(int i=0;i<len;i++){
				pw[len|i]=comp(cos(pi/len*i),sin(pi/len*i));
			}
		}
	}
	void init(int n){
		for(lim=1;lim<n;lim<<=1);
		for(int i=1;i<lim;i++)rev[i]=rev[i>>1]>>1|(i&1?lim>>1:0);
	}
	namespace Public{
		using poly=vector<int>;
		void FFT(comp *a,int op){
			for(int i=0;i<lim;i++)if(rev[i]<i)swap(a[rev[i]],a[i]);
			for(int len=1;len<lim;len<<=1){
				for(int i=0;i<lim;i+=len<<1){
					for(int j=0;j<len;j++){
						comp x=a[i|j],y=a[i|j|len]*pw[len|j];
						a[i|j]=x+y,a[i|j|len]=x-y;
					}
				}
			}
			if(op<0){
				reverse(a+1,a+lim);
				for(int i=0;i<lim;i++)a[i]/=lim;
			}
		}
		void DFT(const poly &a,comp *a0,comp *a1){
			int n=a.size();
			for(int i=0;i<n;i++)a0[i]=comp(a[i]%base,a[i]/base);
			fill(a0+n,a0+lim,comp(0,0));
			FFT(a0,1);
			copy(a0,a0+lim,a1);
			reverse(a1+1,a1+lim);
			for(int i=0;i<lim;i++)a1[i]=conj(a1[i]);
			for(int i=0;i<lim;i++){
				comp p=a0[i],q=a1[i];
				a0[i]=(p+q)*comp(0.5,0);
				a1[i]=(q-p)*comp(0,0.5);
			}
		}
		poly iDFT(comp *c0,comp *c1){
			FFT(c0,-1),FFT(c1,-1);
			auto calc=[&](double x)->ll {
				if(x>0)return Fast.reduce(ll(x+0.5));
				else{
					int res=Fast.reduce(-ll(x-0.5));
					return res?mod-res:0;
				}
			};
			poly c(lim);
			for(int i=0;i<lim;i++){
				c[i]=Fast.reduce(calc(imag(c1[i]))*base*base+calc(real(c0[i]))*base+calc(real(c1[i])));
			}
			return c;
		}
		pair<poly,poly> iDFT(comp *c0,comp *c1,comp *d0,comp *d1){
			for(int i=0;i<lim;i++)c0[i]+=comp(0,1)*d0[i];
			FFT(c0,-1),FFT(c1,-1),FFT(d1,-1);
			auto calc=[&](double x)->ll {
				if(x>0)return Fast.reduce(ll(x+0.5));
				else{
					int res=Fast.reduce(-ll(x-0.5));
					return res?mod-res:0;
				}
			};
			poly c(lim),d(lim);
			for(int i=0;i<lim;i++){
				c[i]=Fast.reduce(calc(imag(c1[i]))*base*base+calc(real(c0[i]))*base+calc(real(c1[i])));
			}
			for(int i=0;i<lim;i++){
				d[i]=Fast.reduce(calc(imag(d1[i]))*base*base+calc(imag(c0[i]))*base+calc(real(d1[i])));
			}
			return make_pair(c,d);
		}
		void inc(comp *a0,comp *a1,comp *b0,comp *b1,comp *c0,comp *c1){
			for(int i=0;i<lim;i++){
				c0[i]+=a1[i]*b0[i]+a0[i]*b1[i];
				c1[i]+=a0[i]*b0[i]+comp(0,1)*a1[i]*b1[i];
			}
		}
		poly operator * (const poly &a,const poly &b){
			int n=a.size(),m=b.size(),k=n+m-1;
			if(min(n,m)<=40){
				poly c(k);
				for(int i=0;i<n;i++){
					for(int j=0;j<m;j++){
						c[i+j]=Fast.reduce(c[i+j]+1ll*a[i]*b[j]);
					}
				}
				return c;
			}
			init(k);
			DFT(a,a0,a1),DFT(b,b0,b1);
			fill(c0,c0+lim,comp(0,0));
			fill(c1,c1+lim,comp(0,0));
			inc(a0,a1,b0,b1,c0,c1);
			auto c=iDFT(c0,c1);
			return c.resize(k),c;
		}
		poly& operator *= (poly &a,const poly &b){
			return a=a*b;
		}
		poly& operator += (poly &a,const poly &b){
			int n=a.size(),m=b.size();
			if(n<m)a.resize(m);
			for(int i=0;i<m;i++)(a[i]+=b[i])>=mod&&(a[i]-=mod);
			return a;
		}
		poly operator + (const poly &a,const poly &b){
			poly c(a);
			return c+=b;
		}
		poly& operator -= (poly &a,const poly &b){
			int n=a.size(),m=b.size();
			if(n<m)a.resize(m);
			for(int i=0;i<m;i++)(a[i]-=b[i])<0&&(a[i]+=mod);
			return a;
		}
		poly operator - (const poly &a,const poly &b){
			poly c(a);
			return c-=b;
		}
		poly operator - (const poly &a){
			return poly()-a;
		}
		poly& operator *= (poly &a,const int &b){
			for(int &x:a)x=Fast.reduce(1ll*x*b);
			return a;
		}
		poly operator * (const poly &a,const int &b){
			poly c(a);
			return c*=b;
		}
		poly& operator %= (poly &a,const int &b){
			if(a.size()>b)a.resize(b);
			return a;
		}
		poly operator % (const poly &a,const int &b){
			poly c(a);
			return c%=b;
		}
		poly inv(poly a,int n=-1){
			if(n==-1)n=a.size();
			if(n==1)return poly(1,1);
			int m=(n+1)/2;
			auto b=inv(a%m,m);
			init(n+m-1);
			static comp a0[N],a1[N],b0[N],b1[N],c0[N],c1[N];
			DFT(a,a0,a1),DFT(b,b0,b1);
			fill(c0,c0+lim,comp(0,0));
			fill(c1,c1+lim,comp(0,0));
			inc(a0,a1,b0,b1,c0,c1);
			a=iDFT(c0,c1),a.resize(n);
			DFT(a,a0,a1);
			fill(c0,c0+lim,comp(0,0));
			fill(c1,c1+lim,comp(0,0));
			inc(a0,a1,b0,b1,c0,c1);
			a=iDFT(c0,c1),a.resize(n);
			return b*2-a;
		}
	}
}
using namespace Poly::Public;
const int N=2e5+10,M=1<<19|10;
int sid,n,m,a[N],b[N],c[N],d[N],e[N],f[N];
using vec=array<poly,2>;
using matrix=array<vec,2>;
#ifdef DEBUG
ostream& operator << (ostream &out,vec a){
	out<<'[';
	for(auto x:a)out<<x<<',';
	return out<<']';
}
ostream& operator << (ostream &out,matrix a){
	out<<'[';
	for(auto x:a)out<<x<<',';
	return out<<']';
}
#endif
matrix operator * (matrix a,matrix b){
	int n=0;
	for(int i:{0,1})for(int j:{0,1})for(int k:{0,1}){
		n=max(n,(int)a[i][j].size()+(int)b[j][k].size()-1);
	}
	matrix c;
	if(n<=50){
		for(int i:{0,1})for(int j:{0,1})for(int k:{0,1}){
			if(!a[i][j].empty()&&!b[j][k].empty())c[i][k]+=a[i][j]*b[j][k];
		}
		return c;
	}
	Poly::init(n),n=Poly::lim;
	static comp a0[2][2][M],a1[2][2][M];
	static comp b0[2][2][M],b1[2][2][M];
	static comp c0[M],c1[M];
	for(int i:{0,1})for(int j:{0,1}){
		DFT(a[i][j],a0[i][j],a1[i][j]);
		DFT(b[i][j],b0[i][j],b1[i][j]);
	}
	for(int i:{0,1})for(int j:{0,1}){
		fill(c0,c0+n,comp(0,0));
		fill(c1,c1+n,comp(0,0));
		for(int k:{0,1})inc(a0[i][k],a1[i][k],b0[k][j],b1[k][j],c0,c1);
		c[i][j]=iDFT(c0,c1);
		for(;!c[i][j].empty()&&!c[i][j].back();c[i][j].pop_back());
	}
	return c;
}
matrix mul(matrix a,matrix b){
	matrix c;
	for(int i:{0,1})for(int j:{0,1})for(int k:{0,1}){
		if(!a[i][j].empty()&&!b[j][k].empty())c[i][k]+=a[i][j]*b[j][k];
	}
	return c;
}
vec solve(int l,int r){
	if(l==r){
		// debug("solve",l,r,vec{poly{b[l],1},poly{e[l]}});
		return vec{poly{b[l],1},poly{e[l]}};
	}
	int mid=(l+r)>>1,n=0;
	auto L=solve(l,mid),R=solve(mid+1,r);
	for(int i:{0,1})for(int j:{0,1})if(!i||!j){
		n=max(n,(int)L[i].size()+(int)R[j].size()-1);
	}
	// debug("solve",l,r);
	Poly::init(n),n=Poly::lim;
	vec t;
	static comp L0[M],L1[M];
	static comp R0[2][M],R1[2][M];
	static comp t0[2][M],t1[2][M];
	DFT(L[0],L0,L1);
	for(int i:{0,1}){
		fill(t0[i],t0[i]+n,comp(0,0));
		fill(t1[i],t1[i]+n,comp(0,0));
		DFT(R[i],R0[i],R1[i]);
	}
	inc(L0,L1,R0[0],R1[0],t0[0],t1[0]);
	inc(L0,L1,R0[1],R1[1],t0[1],t1[1]);
	tie(t[0],t[1])=iDFT(t0[0],t1[0],t0[1],t1[1]);
	for(int i:{0,1}){
		for(;!t[i].empty()&&!t[i].back();t[i].pop_back());
	}
	t[1]+=L[1];
	// debug("solve",l,r,t);
	return t;
}
struct node{
	matrix F;
	poly G[2][3];
	poly calc(int cr){
		return F[0][0]*poly{(mod-cr)%mod,1}+F[0][1];
	}
	void mul(poly g,int k){
		Poly::init(G[0][0].size()+g.size()-1);
		int n=Poly::lim;
		static comp g0[M],g1[M],w0[2][M],w1[2][M];
		static comp G0[M],G1[M];
		DFT(g,g0,g1);
		for(int j:{0,1,2}){
			for(int i:{0,1}){
				DFT(G[i][j],G0,G1);
				fill(w0[i],w0[i]+n,comp(0,0));
				fill(w1[i],w1[i]+n,comp(0,0));
				inc(g0,g1,G0,G1,w0[i],w1[i]);
			}
			tie(G[0][j],G[1][j])=iDFT(w0[0],w1[0],w0[1],w1[1]);
			G[0][j].resize(k),G[1][j].resize(k);
		}
	}
};
void expand(poly &a,poly f,poly g,int m){
	int n=a.size();
	if(m<=n)return a%=m,void();
	a=a*f%n*g%m;
}
const int K=400;
matrix gen(int i){
	matrix cur;
	cur[0][0]=poly{(mod-c[i])%mod,1};
	cur[0][1]=poly{int(1ll*(mod-a[i])*d[i+1]%mod)};
	cur[1][0]=poly{1};
	return cur;
}
node divide(int l,int r){
	int n=r-l+1;
	if(r-l+1<=K){
		node res;
		function<matrix(int,int)>dfs=[&](int l,int r){
			if(l==r)return gen(l);
			int mid=(l+r)>>1;
			return dfs(l,mid)*dfs(mid+1,r);
		};
		if(l<r)res.F=dfs(l,r-1);
		else res.F[0][0]=res.F[1][1]=poly{1};
		static int w[K][N];
		for(int x:{0,1}){
			for(int i=0;i<n;i++)fill(w[i]+l,w[i]+1+r,0);
			w[0][x?r:l]=1;
			for(int i=0;i+1<n;i++){
				for(int j=l;j<=r;j++)w[i+1][j]=Fast.reduce(w[i+1][j]+1ll*w[i][j]*c[j]);
				for(int j=l;j<r;j++)w[i+1][j+1]=Fast.reduce(w[i+1][j+1]+1ll*w[i][j]*a[j]);
				for(int j=r;j>l;j--)w[i+1][j-1]=Fast.reduce(w[i+1][j-1]+1ll*w[i][j]*d[j]);
			}
			res.G[x][0].resize(n);
			res.G[x][1].resize(n);
			res.G[x][2].resize(n);
			for(int i=0;i<n;i++){
				res.G[x][0][i]=Fast.reduce(res.G[x][0][i]+w[i][l]);
				res.G[x][1][i]=Fast.reduce(res.G[x][1][i]+w[i][r]);
				for(int j=l;j<=r;j++){
					res.G[x][2][i]=Fast.reduce(res.G[x][2][i]+1ll*w[i][j]*f[j]);
				}
			}
		}
		return res;
	}
	int mid=(l+r)>>1;
	auto L=divide(l,mid-1),R=divide(mid+1,r);
	auto fl=L.calc(c[mid-1]),fr=R.calc(c[r]);
	reverse(all(fl)),reverse(all(fr));
	auto ifl=inv(fl,n),ifr=inv(fr,n);
	L.mul(fl,mid-l),R.mul(fr,r-mid);
	L.mul(ifl,n),R.mul(ifr,n);
	node res;
	res.F=mul(L.F,gen(mid-1))*mul(gen(mid),R.F);
	poly h=(poly{0,c[mid]}+
		L.G[1][1]*poly{0,0,int(1ll*d[mid]*a[mid-1]%mod)}+
		R.G[0][0]*poly{0,0,int(1ll*a[mid]*d[mid+1]%mod)})%n;
	h=inv(poly{1}-h,n);
	poly p[2],q[3];
	p[0]=poly{0,a[mid-1]}*L.G[0][1]%n;
	p[1]=poly{0,d[mid+1]}*R.G[1][0]%n;
	q[0]=poly{0,d[mid]}*L.G[1][0]%n;
	q[1]=poly{0,a[mid]}*R.G[0][1]%n;
	q[2]=(poly{0,d[mid]}*L.G[1][2]+poly{0,a[mid]}*R.G[0][2]+poly{f[mid]})%n;
	Poly::init(n+n-1);
	int k=Poly::lim;
	static comp p0[2][M],p1[2][M],h0[M],h1[M],w0[2][M],w1[2][M];
	DFT(p[0],p0[0],p1[0]);
	DFT(p[1],p0[1],p1[1]);
	DFT(h,h0,h1);
	fill(w0[0],w0[0]+k,comp(0,0));
	fill(w1[0],w1[0]+k,comp(0,0));
	inc(p0[0],p1[0],h0,h1,w0[0],w1[0]);
	fill(w0[1],w0[1]+k,comp(0,0));
	fill(w1[1],w1[1]+k,comp(0,0));
	inc(p0[1],p1[1],h0,h1,w0[1],w1[1]);
	tie(p[0],p[1])=iDFT(w0[0],w1[0],w0[1],w1[1]);
	p[0].resize(n),p[1].resize(n);
	static comp q0[3][M],q1[3][M];
	static comp G0[2][3][M],G1[2][3][M];
	DFT(p[0],p0[0],p1[0]);
	DFT(p[1],p0[1],p1[1]);
	for(int c:{0,1,2})DFT(q[c],q0[c],q1[c]);
	for(int i:{0,1})for(int j:{0,1,2}){
		fill(G0[i][j],G0[i][j]+k,comp(0,0));
		fill(G1[i][j],G1[i][j]+k,comp(0,0));
	}
	for(int i:{0,1})for(int j:{0,1,2}){
		inc(p0[i],p1[i],q0[j],q1[j],G0[i][j],G1[i][j]);
	}
	for(int j:{0,1,2}){
		tie(res.G[0][j],res.G[1][j])=iDFT(G0[0][j],G1[0][j],G0[1][j],G1[1][j]);
		res.G[0][j].resize(n),res.G[1][j].resize(n);
	}
	res.G[0][0]+=L.G[0][0];
	res.G[0][2]+=L.G[0][2];
	res.G[1][1]+=R.G[1][1];
	res.G[1][2]+=R.G[1][2];
	return res;
}
int main(){
	Poly::Init();
	scanf("%d%d%d%d",&sid,&n,&m,&mod);
	Fast=fastmod(mod);
	if(mod==1)puts("0"),exit(0);
	base=sqrt(mod);
	for(int i=0;i<m;i++)scanf("%d",&a[i]);
	for(int i=0;i<n;i++)scanf("%d",&b[i]);
	for(int i=0;i<=m;i++)scanf("%d",&c[i]);
	for(int i=1;i<=m;i++)scanf("%d",&d[i]);
	for(int i=0;i<=n;i++)scanf("%d",&e[i]);
	for(int i=0;i<=m;i++)scanf("%d",&f[i]);
	poly h=solve(0,n)[1];
	h.resize(n+1);
	// debug(h);
	node res=divide(0,m);
	poly f=res.calc(c[m]),g=res.G[0][2];
	reverse(all(f));
	expand(g,f,inv(f,n+1),n+1);
	// debug(f);
	// for(int i:{0,1})for(int j:{0,1,2}){
	// 	poly t;
	// 	for(int x=0;x<res.G[i][j].size()&&x<10;x++)t.push_back(res.G[i][j][x]);
	// 	debug(i,j,t);
	// }
	// debug(g,res.G[0][2],h,f);
	int ans=0;
	for(int i=0;i<=n;i++)ans=Fast.reduce(ans+1ll*h[i]*g[i]);
	cout<<ans<<endl;
	return 0;
}
#ifdef DEBUG
#include"debug.hpp"
#endif