#include <iostream>
#include <cstdio>
#include <cctype>
#define il inline
#define ll long long
#define R register
#define gc getchar
#define int long long
using namespace std;
il int read()
{
	int x=0;bool f=0;char ch=gc();
	while(!isdigit(ch)) {f|=ch=='-';ch=gc();}
	while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=gc();}
	return f?-x:x;
}

il ll max(int a,int b)
{
	return a>b?a:b;
}

il int min(int a,int b)
{
	return a<b?a:b;
}

il void swap(int &A,int &B)
{
	A^=B^=A^=B;
}


const int MAXN=1e5+10;
int n,m;
int a[MAXN];

//-----------------------链式前向星------------------------ 
int head[MAXN],tot;
struct w_star{
	int next,to;
}e[MAXN<<1];
il void add(int u,int v)
{
	e[++tot]=(w_star){head[u],v};
	head[u]=tot;
}

//-----------------------链式前向星------------------------ 

//----------------------树剖的两个dfs----------------------
int dep[MAXN],fa[MAXN],size[MAXN],son[MAXN];
il void dfs(int u,int father)
{
	dep[u]=dep[father]+1;size[u]=1;fa[u]=father;
	for(R int i=head[u];i;i=e[i].next)
	{
		int to=e[i].to;
		if(to==father) continue;
		dfs(to,u);
		size[u]+=size[to];
		if(size[to]>size[son[u]]) son[u]=to;
	}
}

int top[MAXN],id[MAXN],rank[MAXN],dfstime;
il void dfs1(int u,int topp)
{
	top[u]=topp;id[u]=++dfstime;rank[dfstime]=u;
	if(son[u]) dfs1(son[u],topp);
	for(R int i=head[u];i;i=e[i].next)
	{
		int to=e[i].to;
		if(!top[to]) dfs1(to,to);
	}
}

//----------------------树剖的两个dfs----------------------

//----------------------线段树维护------------------------- 
#define ls (k<<1)
#define rs ((k<<1)|1) 
struct w_tree{
	int l,r;
	ll lazy,sum;
}tree[MAXN<<2];
il void pushup(int k)
{
	tree[k].sum=tree[ls].sum+tree[rs].sum;
}

il void build(int k,int l,int r)
{
	tree[k].l=l;tree[k].r=r;
	if(l==r)
	{
		tree[k].sum=a[rank[l]];
		return ;
	}
	int mid=(l+r)>>1;
	build(ls,l,mid);build(rs,mid+1,r);
	pushup(k);
}

il void pushdown(int k)
{
	if(tree[k].l==tree[k].r) return ;
	tree[ls].lazy+=tree[k].lazy;
	tree[rs].lazy+=tree[k].lazy;
	tree[ls].sum+=(tree[ls].r-tree[ls].l+1)*tree[k].lazy;
	tree[rs].sum+=(tree[rs].r-tree[rs].l+1)*tree[k].lazy;
	tree[k].lazy=0;
}

il void change(int k,int x,int y,int val)
{
	int l=tree[k].l,r=tree[k].r;
	if(y<l||r<x) return ;
	if(x<=l&&r<=y)
	{
		tree[k].lazy+=val;
		tree[k].sum+=val*(r-l+1);
		return ;
	}
	if(l==r) return ;
	if(tree[k].lazy) pushdown(k);
	change(ls,x,y,val);change(rs,x,y,val);
	pushup(k);
}

il ll ask(int k,int x,int y)
{
	int l=tree[k].l,r=tree[k].r;
	if(y<l||r<x) return 0;
	if(x<=l&&r<=y) return tree[k].sum;
	if(l==r) return 0;
	if(tree[k].lazy) pushdown(k);
	return ask(ls,x,y)+ask(rs,x,y);
}

//----------------------线段树维护------------------------- 

//----------------------树剖操作--------------------------
il void operate1(int x,int val)
{
	change(1,id[x],id[x],val);
} 

il void operate2(int x,int val)
{
	change(1,id[x],id[x]+size[x]-1,val);
}

il ll operate3(int x,int y)
{
	ll ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans+=ask(1,id[top[x]],id[x]);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans+=ask(1,id[x],id[y]);
	return ans;
}

//----------------------树剖操作--------------------------


signed main()
{
	n=read();m=read();
	for(R int i=1;i<=n;++i) a[i]=read();
	for(R int i=1;i<n;++i)
	{
		int u=read(),v=read();
		add(u,v);add(v,u);
	}
	dfs(1,0);dfs1(1,1);build(1,1,n);
	while(m--)
	{
		int opt=read();
		if(opt==1) operate1(read(),read());
		if(opt==2) operate2(read(),read());
		if(opt==3) printf("%lld\n",operate3(1,read()));
	}
	return 0;
}