#include<iostream>
#include<cstdio>
#include<map>
#include<algorithm>
#include<random>
#include<vector>
#define N 400000
#define W 5000000
#define K 35000000
#define M 5000
#define Z 1048575
#define mod 998244353
using namespace std;
mt19937 RAND(random_device{}());
const long long inf=(long long)(1e18);
long long read()
{
	char c=0;
	long long sum=0;
	while (c<'0'||c>'9') c=getchar();
	while ('0'<=c&&c<='9') sum=sum*10+c-'0',c=getchar();
	return sum;
}
int fast_pow(int a,int b)
{
	int res=1,mul=a;
	while (b)
	{
		if (b&1) res=1ll*res*mul%mod;
		mul=1ll*mul*mul%mod,b>>=1;
	}
	return res;
}
int MD(int x)
{
	return x>=mod?x-mod:x;
}
int MD2(int x)
{
	return x<0?x+mod:x;
}
void Adder(int &x,int d)
{
	x=x+d>=mod?x+d-mod:x+d;
	return;
}
void Adder2(int &x,int d)
{
	x=x+d<0?x+d+mod:x+d;
	return;
}
long long n,ds,dw;
long long gcd(long long a,long long b)
{
	if (!b) return a;
	else return gcd(b,a%b);
}
int m,q,t,rest,lengz,ans[N+1],sz[N+1],ls[N+1],rs[N+1],Y[N+1],p[N+1],rt[M+1],srt[M+1],rd[Z+1],rd2[Z+1],rd3[Z+1];
long long X[N+1];
bool used[N+1];
vector<int>v[N+1];
vector<int>sv[N+1];
vector<long long>st[N+1];
map<long long,int>P;
struct rds
{
	int mul,wl,wr,res,res2;
};
rds c,zero,delta[N+1];
rds operator + (rds a,rds b)
{
	return (rds){1ll*a.mul*b.mul%mod,(a.wl+1ll*a.mul*b.wl)%mod,(b.wr+1ll*b.mul*a.wr)%mod,(a.res+b.res+1ll*a.wr*b.wl)%mod,(1ull*a.res2*b.mul+1ull*b.res2*a.mul+1ull*MD2(a.wl+1-a.mul)*MD2(b.wr+1-b.mul))%mod};
}
long long calc(rds a)
{
	int res=MD(a.res+a.res2);
	Adder2(res,-a.mul),Adder2(res,-MD2(a.wl-a.mul)),Adder2(res,-MD2(a.wr-a.mul)),Adder2(res,-1);
	res=1ll*res*fast_pow(MD2(1-a.mul),mod-2)%mod;
	return res;
}
struct WBLT
{
	struct node
	{
		int ls,rs;
		long long sz;
		rds data;
	};
	node tree[W+1];
	int length;
	int new_node(int d)
	{
		++length,tree[length]=(node){0,0,1,(rds){d,d,d,MD(d+1),1}};
		return length;
	}
	void push_up(int k)
	{
		tree[k].sz=tree[tree[k].ls].sz+tree[tree[k].rs].sz,tree[k].data=tree[tree[k].ls].data+tree[tree[k].rs].data;
		return;
	}
	rds query(long long k,long long L,long long R,long long l,long long r)
	{
		if (L==l&&R==r) return tree[k].data;
		long long mid=L+tree[tree[k].ls].sz-1;
		if (r<=mid) return query(tree[k].ls,L,mid,l,r);
		else if (l>=mid+1) return query(tree[k].rs,mid+1,R,l,r);
		else return query(tree[k].ls,L,mid,l,mid)+query(tree[k].rs,mid+1,R,mid+1,r);
	}
};
WBLT T;
struct seg
{
	struct node
	{
		int ls,rs;
		rds data;
	};
	node tree[K+1];
	int length;
	void push_up(int k)
	{
		tree[k].data=tree[tree[k].ls].data+tree[tree[k].rs].data;
		return;
	}
	int build(int l,int r)
	{
		int nw=++length;
		if (l==r)
		{
			tree[nw].data=delta[l];
			return nw;
		}
		int mid=(l+r)>>1;
		tree[nw].ls=build(l,mid),tree[nw].rs=build(mid+1,r),push_up(nw);
		return nw;
	}
	int add(int k,int L,int R,int x,rds d)
	{
		int nw=++length;
		tree[nw]=tree[k];
		if (L==R)
		{
			tree[nw].data=d;
			return nw;
		}
		int mid=(L+R)>>1;
		if (x<=mid) tree[nw].ls=add(tree[nw].ls,L,mid,x,d);
		else tree[nw].rs=add(tree[nw].rs,mid+1,R,x,d);
		push_up(nw);
		return nw;
	}
};
seg T2;
struct reads
{
	int d[M+1],res;
};
reads e,d1,d2,d3;
int merge(int x,int y)
{
	if (!x||!y) return x^y;
	int nw=++T.length;
	T.tree[nw].ls=x,T.tree[nw].rs=y,T.push_up(nw);
	return nw;
}
reads operator * (reads a,reads b)
{
	for (int i=0;i<m;++i) a.d[i]=merge(a.d[i],b.d[(i+a.res)%m]);
	a.res=(a.res+b.res)%m;
	return a;
}
reads fast_pow(reads a,long long b)
{
	reads res=e,mul=a;
	while (b)
	{
		if (b&1) res=res*mul;
		if (b) mul=mul*mul;
		b>>=1;
	}
	return res;
}
reads solve(long long x,long long a,long long b,long long c,reads d1,reads d2)
{
	if (!x) return e;
	if (b>=c) return fast_pow(d1,b/c)*solve(x,a,b%c,c,d1,d2);
	if (a>=c) return solve(x,a%c,b,c,d1,fast_pow(d1,a/c)*d2);
	long long y=((__int128)(a)*x+b)/c;
	if (!y) return fast_pow(d2,x);
	return fast_pow(d2,(c-b-1)/a)*d1*solve(y-1,c,(c-b-1)%a,a,d2,d1)*fast_pow(d2,x-((__int128)(c)*y-b-1)/a);
}
long long sx,sy;
void exgcd(long long a,long long b)
{
	if (!b)
	{
		sx=1,sy=0;
		return;
	}
	exgcd(b,a%b);
	long long tx=sx-(a/b)*sy;
	sx=sy,sy=tx;
	return;
}
long long get_inv(long long a,long long p)
{
	exgcd(a,p);
	return (sx%p+p)%p;
}
struct node
{
	long long num;
	int data,nxt;
};
node edge[N+1],edge2[N+1];
int head[Z+1],head2[Z+1],len,len2;
void insert(long long x,int d)
{
	int sx=rd[x&Z]^rd2[(x>>20)&Z]^rd3[x>>40];
	edge[++len]=(node){x,d,head[sx]},head[sx]=len;
	return;
}
int find(long long x)
{
	int sx=rd[x&Z]^rd2[(x>>20)&Z]^rd3[x>>40];
	for (int i=head[sx];i>0;i=edge[i].nxt)
		if (edge[i].num==x)
			return edge[i].data;
	return -1;
}
void insert2(long long x,int d)
{
	int sx=rd[x&Z]^rd2[(x>>20)&Z]^rd3[x>>40];
	edge2[++len2]=(node){x,d,head2[sx]},head2[sx]=len2;
	return;
}
int find2(long long x)
{
	int sx=rd[x&Z]^rd2[(x>>20)&Z]^rd3[x>>40];
	for (int i=head2[sx];i>0;i=edge2[i].nxt)
		if (edge2[i].num==x)
			return edge2[i].data;
	return -1;
}
void change(long long x,int d)
{
	int ds,pst=find2(x);
	if (find(x%dw)==-1) insert(x%dw,++lengz);
	ds=find(x%dw);
	if (sv[ds].empty()) sv[ds].push_back(srt[(x%dw)%m]);
	Adder2(rest,-calc(T2.tree[sv[ds].back()].data)),sv[ds].push_back(T2.add(sv[ds].back(),0,st[(x%dw)%m].size()-1,pst,(rds){d,d,d,MD(d+1),1})),Adder(rest,calc(T2.tree[sv[ds].back()].data));
	return;
}
void undo(long long x)
{
	int ds=find(x%dw);
	Adder2(rest,-calc(T2.tree[sv[ds].back()].data)),sv[ds].pop_back(),Adder(rest,calc(T2.tree[sv[ds].back()].data));
	return;
}
void dfs(int x)
{
	if (!ls[x])
	{
		sz[x]=1;
		return;
	}
	dfs(ls[x]),dfs(rs[x]),sz[x]=sz[ls[x]]+sz[rs[x]];
	return;
}
void dfs2(int x)
{
	if (!ls[x])
	{
		change(X[x],Y[x]),ans[x]=rest,v[x].push_back(x);
		return;
	}
	if (sz[ls[x]]>sz[rs[x]])
	{
		dfs2(rs[x]);
		for (int i=0;i<v[rs[x]].size();++i) undo(X[v[rs[x]][i]]);
		dfs2(ls[x]);
		for (int i=0;i<v[rs[x]].size();++i) change(X[v[rs[x]][i]],Y[v[rs[x]][i]]);
		ans[x]=rest,swap(v[x],v[ls[x]]);
		for (int i=0;i<v[rs[x]].size();++i) v[x].push_back(v[rs[x]][i]);
	}
	else
	{
		dfs2(ls[x]);
		for (int i=0;i<v[ls[x]].size();++i) undo(X[v[ls[x]][i]]);
		dfs2(rs[x]);
		for (int i=0;i<v[ls[x]].size();++i) change(X[v[ls[x]][i]],Y[v[ls[x]][i]]);
		ans[x]=rest,swap(v[x],v[rs[x]]);
		for (int i=0;i<v[ls[x]].size();++i) v[x].push_back(v[ls[x]][i]);
	}
	return;
}
int main()
{
	int a,b,pst;
	long long x,ps;
	reads rts;
	for (int i=0;i<=Z;++i) rd[i]=RAND()&Z,rd2[i]=RAND()&Z,rd3[i]=RAND()&Z;
	n=read(),m=read(),ds=read(),q=read(),t=read();
	for (int i=0;i<m;++i) p[i]=read(),T.new_node(p[i]);
	d1.res=(m-n%m)%m,d2.res=ds%m,d3.res=(n-ds)%m;
	for (int i=0;i<m;++i) d2.d[i]=(i+ds)%m+1;
	dw=gcd(n,ds),rts=d3*solve(n/dw,ds,n-ds,n,d1,d2);
	for (int i=0;i<m;++i) rt[i]=rts.d[i],Adder(rest,1ll*calc(T.tree[rt[i]].data)*(((dw+m-1-i)/m)%mod)%mod);
	ans[0]=rest;
	for (int i=1;i<=q;++i)
	{
		X[i]=read(),Y[i]=read(),ps=(__int128)(X[i]/dw)*get_inv(ds/dw,n/dw)%(n/dw),st[(X[i]%dw)%m].push_back(ps);
		if (ps) st[(X[i]%dw)%m].push_back(ps-1);
	}
	for (int i=0;i<m;++i)
		if (!st[i].empty())
		{
			st[i].push_back(T.tree[rt[i]].sz-1),sort(st[i].begin(),st[i].end()),st[i].resize(unique(st[i].begin(),st[i].end())-st[i].begin()),ps=-1;
			for (int j=0;j<st[i].size();++j) delta[j]=T.query(rt[i],0,T.tree[rt[i]].sz-1,ps+1,st[i][j]),ps=st[i][j];
			srt[i]=T2.build(0,st[i].size()-1);
		}
	for (int i=1;i<=q;++i)
	{
		x=X[i],ps=(__int128)(x/dw)*get_inv(ds/dw,n/dw)%(n/dw);
		pst=lower_bound(st[(x%dw)%m].begin(),st[(x%dw)%m].end(),ps)-st[(x%dw)%m].begin(),insert2(x,pst);
	}
	for (int i=1;i<=t;++i) a=read(),b=read(),ls[q+i]=a,rs[q+i]=b;
	for (int i=1;i<=q+t;++i)
	{
		if (ls[i]) used[ls[i]]=1;
		if (rs[i]) used[rs[i]]=1;
	}
	for (int i=1;i<=q+t;++i)
		if (!used[i])
		{
			dfs(i),dfs2(i);
			for (int j=0;j<v[i].size();++j) undo(X[v[i][j]]);
		}
	for (int i=0;i<=q+t;++i) printf("%d\n",ans[i]);
	return 0;
}