const int MAXN=1e5+5;
int mod;
struct Tree{
LL a[MAXN<<2],sum[MAXN<<2],lazy[MAXN<<2];
int lef[MAXN<<2],rig[MAXN<<2];
void init(int n,int *w){
_rep(i,1,n)
a[i]=w[i];
build(1,1,n);
}
void push_up(int k){
sum[k]=(sum[k<<1]+sum[k<<1|1])%mod;
}
void build(int k,int L,int R){
lef[k]=L,rig[k]=R;
int M=L+R>>1;
if(L==R)
return sum[k]=a[M],void();
build(k<<1,L,M);
build(k<<1|1,M+1,R);
push_up(k);
}
void push_down(int k){
if(lazy[k]){
int lson=k<<1,rson=k<<1|1;
lazy[lson]=(lazy[lson]+lazy[k])%mod;
sum[lson]=(sum[lson]+lazy[k]*(rig[lson]-lef[lson]+1))%mod;
lazy[rson]=(lazy[rson]+lazy[k])%mod;
sum[rson]=(sum[rson]+lazy[k]*(rig[rson]-lef[rson]+1))%mod;
lazy[k]=0;
}
}
LL query(int k,int L,int R){
if(L<=lef[k]&&rig[k]<=R)
return sum[k];
push_down(k);
int mid=lef[k]+rig[k]>>1;
if(mid>=R)
return query(k<<1,L,R);
else if(mid<L)
return query(k<<1|1,L,R);
else
return (query(k<<1,L,R)+query(k<<1|1,L,R))%mod;
}
void update(int k,int L,int R,LL v){
if(L<=lef[k]&&rig[k]<=R){
sum[k]=(sum[k]+(rig[k]-lef[k]+1)*v)%mod;
lazy[k]=(lazy[k]+v)%mod;
return;
}
push_down(k);
int mid=lef[k]+rig[k]>>1;
if(mid>=L)
update(k<<1,L,R,v);
if(mid<R)
update(k<<1|1,L,R,v);
push_up(k);
}
}tree;
struct Edge{
int to,next;
}edge[MAXN<<1];
int head[MAXN],m;
void Insert(int u,int v){
edge[++m].to=v;
edge[m].next=head[u];
head[u]=m;
}
int d[MAXN],w[MAXN],sz[MAXN],f[MAXN],dfn[MAXN],dfs_t;
int h_son[MAXN],mson[MAXN],p[MAXN],dfw[MAXN];
void dfs_1(int u,int fa,int depth){
sz[u]=1,f[u]=fa,d[u]=depth,mson[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(v==fa)
continue;
dfs_1(v,u,depth+1);
sz[u]+=sz[v];
if(sz[v]>mson[u]){
h_son[u]=v;
mson[u]=sz[v];
}
}
}
void dfs_2(int u,int top){
dfn[u]=++dfs_t,p[u]=top;
dfw[dfs_t]=w[u];
if(mson[u])
dfs_2(h_son[u],top);
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(v==f[u]||v==h_son[u])
continue;
dfs_2(v,v);
}
}
int query_path(int u,int v){
LL ans=0;
while(p[u]!=p[v]){
if(d[p[u]]<d[p[v]])
swap(u,v);
ans=(ans+tree.query(1,dfn[p[u]],dfn[u]))%mod;
u=f[p[u]];
}
if(d[u]>d[v])
swap(u,v);
ans=(ans+tree.query(1,dfn[u],dfn[v]))%mod;
return ans;
}
void update_path(int u,int v,int w){
while(p[u]!=p[v]){
if(d[p[u]]<d[p[v]])
swap(u,v);
tree.update(1,dfn[p[u]],dfn[u],w);
u=f[p[u]];
}
if(d[u]>d[v])
swap(u,v);
tree.update(1,dfn[u],dfn[v],w);
}
int query_son(int u){return tree.query(1,dfn[u],dfn[u]+sz[u]-1);}
void update_son(int u,int w){tree.update(1,dfn[u],dfn[u]+sz[u]-1,w);}
int main()
{
int n=read_int(),q=read_int(),root=read_int(),opt,x,y,z;
mod=read_int();
_rep(i,1,n)
w[i]=read_LL()%mod;
_for(i,1,n){
x=read_int(),y=read_int();
Insert(x,y);
Insert(y,x);
}
dfs_1(root,-1,0);
dfs_2(root,root);
tree.init(n,dfs_w);
while(q--){
opt=read_int();
if(opt==1){
x=read_int();y=read_int();z=read_int();
update_path(x,y,z);
}
else if(opt==2){
x=read_int();y=read_int();
enter(query_path(x,y));
}
else if(opt==3){
x=read_int();y=read_int();
update_son(x,y);
}
else
enter(query_son(read_int()));
}
return 0;
}
