#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cctype>
#define _for(i,a,b) for(int i=(a);i<(b);++i)
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef long long LL;
inline int read_int(){
int t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline LL read_LL(){
LL t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline void write(LL x){
register char c[21],len=0;
if(!x)return putchar('0'),void();
if(x<0)x=-x,putchar('-');
while(x)c[++len]=x%10,x/=10;
while(len)putchar(c[len--]+48);
}
inline void space(LL x){write(x),putchar(' ');}
inline void enter(LL x){write(x),putchar('\n');}
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],dfs_id[MAXN],dfs_t;
int h_son[MAXN],mson[MAXN],p[MAXN],dfs_w[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){
dfs_id[u]=++dfs_t;p[u]=top;dfs_w[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);
}
}
LL query_son(int u){return tree.query(1,dfs_id[u],dfs_id[u]+sz[u]-1);}
void update_son(int u,int w){tree.update(1,dfs_id[u],dfs_id[u]+sz[u]-1,w);}
LL 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,dfs_id[p[u]],dfs_id[u]))%mod;
u=f[p[u]];
}
if(d[u]>d[v])
swap(u,v);
ans=(ans+tree.query(1,dfs_id[u],dfs_id[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,dfs_id[p[u]],dfs_id[u],w);
u=f[p[u]];
}
if(d[u]>d[v])
swap(u,v);
tree.update(1,dfs_id[u],dfs_id[v],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;
}
