#include<iostream>

#include<cstdlib>

#include<cstdio>

#include<cmath>

#include<cstring>

#include<iomanip>

#include<algorithm>

#include<ctime>

#include<queue>

#define rg register

#define lst long long

#define N 100050

#define ls (now<<1)

#define rs (now<<1|1)

using namespace std;

int n,m,root,p,cnt,ss,ans;

struct EDGE{

    int to,nxt;

}edge[N<<];

struct TREE{

    int l,r,siz,sum,lazy;

}ljl[N<<];

int first[N],v[N];

int fa[N],deep[N],son[N],size[N],top[N],num[N],vv[N];

inline int read()

{

    rg int s=,m=;rg char ch=getchar();

    while(ch!='-'&&(ch<''||ch>''))ch=getchar();

    if(ch=='-')m=-,ch=getchar();

    while(ch>=''&&ch<='')s=(s<<)+(s<<)+ch-'',ch=getchar();

    return s*m;

}

inline void add(rg int p,rg int q){edge[++cnt]=(EDGE){q,first[p]};first[p]=cnt;}

void init()//输入点权和加边

{

    n=read(),m=read(),root=read(),p=read();

    for(rg int i=;i<=n;++i)v[i]=read(),size[i]=;

    for(rg int i=;i<n;++i)

    {

        rg int p=read(),q=read();

        add(p,q),add(q,p);

    }

}

//______________________________________________输入，加边

void dfs_1(rg int now,rg int dep,rg int fm)//Dfs预处理 父亲节点 深度 子树大小

{

    rg int kk=;//辅助找重儿子

    fa[now]=fm,deep[now]=dep;//父亲，深度

    for(rg int i=first[now];i;i=edge[i].nxt)//枚举儿子节点(边)

    {

        rg int qw=edge[i].to;//儿子

        if(qw==fm)continue;

        dfs_1(qw,dep+,now);//继续去找

        size[now]+=size[qw];//处理子树大小

        if(size[qw]>kk)kk=size[qw],son[now]=qw;//找重儿子

    }

}

void dfs_2(rg int now,rg int up)//找新的dfs序vv 处理now在dfs序中的位置num 所在重链的顶端

{

    num[now]=++ss,top[now]=up,vv[ss]=v[now];//如上

    if(son[now])dfs_2(son[now],top[now]);//先递归找重儿子

    for(rg int i=first[now];i;i=edge[i].nxt)//再找其他儿子(边)

    {

        rg int qw=edge[i].to;

        if(qw!=fa[now]&&qw!=son[now])//如上

            dfs_2(qw,qw);

    }

}

//__________________________________________________________dfs预处理

inline void Pushup(rg int now)//处理一下和

{

    ljl[now].sum=(ljl[ls].sum+ljl[rs].sum+p)%p;

}

inline void Pushdown(rg int now)//lazy标记下放

{

    if(ljl[now].lazy)

    {

        ljl[ls].sum+=ljl[ls].siz*ljl[now].lazy;ljl[ls].sum%=p;

        ljl[rs].sum+=ljl[rs].siz*ljl[now].lazy;ljl[rs].sum%=p;

        ljl[ls].lazy+=ljl[now].lazy;ljl[ls].lazy%=p;

        ljl[rs].lazy+=ljl[now].lazy;ljl[rs].lazy%=p;

        ljl[now].lazy=;

    }

}

void build(rg int now,rg int ll,rg int rr)//建线段树

{

    ljl[now]=(TREE){ll,rr,rr-ll+};

    if(ll==rr){ljl[now].sum=vv[ll];return;}

    rg int mid=(ll+rr)>>;

    build(ls,ll,mid),build(rs,mid+,rr);

    Pushup(now);

}

void update(rg int now,rg int ll,rg int rr ,rg int xx)//区间ll到rr上加一个xx

{

    if(ljl[now].l>=ll&&ljl[now].r<=rr)

    {

        ljl[now].sum+=ljl[now].siz*xx;

        ljl[now].lazy+=xx;return;

    }

    Pushdown(now);

    rg int mid=(ljl[now].l+ljl[now].r)/;

    if(rr<=mid)update(ls,ll,rr,xx);

    if(ll>mid)update(rs,ll,rr,xx);

    if(ll<=mid&&rr>mid)

        update(ls,ll,mid,xx),update(rs,mid+,rr,xx);

    Pushup(now);

}

int Query(rg int now,rg int ll,rg int rr)//求ll到rr区间的和

{

    rg int s=;

    if(ljl[now].l>=ll&&ljl[now].r<=rr)return ljl[now].sum;

    Pushdown(now);

    rg int mid=(ljl[now].l+ljl[now].r)>>;

    if(rr<=mid)s+=Query(ls,ll,rr);

    if(ll>mid) s+=Query(rs,ll,rr);

    if(ll<=mid&&rr>mid)

        s+=Query(ls,ll,mid)+Query(rs,mid+,rr);

    Pushup(now),s%=p;

    return s;

}

//__________________________________________________________线段树

inline void tree_work(rg int x,rg int y,rg int z,rg int op)

{

    if(num[x]>num[y])swap(x,y);

    if(!op)update(,num[x],num[y],z);

    else ans+=Query(,num[x],num[y]);ans%=p;

}

inline void tree_Work(rg int x,rg int y,rg int z,rg int op)

{

    while(top[x]!=top[y])

    {

        if(deep[top[x]]<deep[top[y]])swap(x,y);

        tree_work(top[x],x,z,op);

        x=fa[top[x]];

    }

    tree_work(x,y,z,op);

}

inline void ANS()

{

    for(rg int i=;i<=m;++i)

    {

        rg int type=read();ans=;

        if(type==){rg int x=read(),y=read(),z=read();          tree_Work(x,y,z,);}

        if(type==){rg int x=read(),y=read();                   tree_Work(x,y,,);}

        if(type==){rg int x=read(),z=read();  update(,num[x],num[x]+size[x]-,z);}

        if(type==){rg int x=read();          ans=Query(,num[x],num[x]+size[x]-);}

        if(type==||type==)printf("%d\n",ans);

    }

}

int main()

{

    init();

    dfs_1(root,,);

    dfs_2(root,root);

    build(,,ss);

    ANS();

    return ;

}