开了 $long \ long$ ，但还是没过。

#include <map>
#include <queue>
#include <cmath>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

namespace oi{
	template <class T>
	inline T Abs(T x){return x > 0 ? x : -x;}

	template <class T>
	inline T Max(T a, T b){return a > b ? a : b;}
	template <class T, class... TT>
	inline T Max(T a, TT... b){
		T res = Max(b...);
		return Max(a, res);
	}

	template <class T>
	inline T Min(T a, T b){return a < b ? a : b;}
	template <class T, class... TT>
	inline T Min(T a, TT... b){
		T res = Min(b...);
		return Min(a, res);
	}

	template <class T>
	inline void read(T &x){
		x = 0;
		char ch = getchar();
		bool flag = 0;
		while(ch < '0' || ch > '9') flag |= ch == '-', ch = getchar();
		while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
		flag ? x = -x : 0;
	}
	template <class T, class... TT>
	inline void read(T &x, TT &...xx){
		read(x), read(xx...);
	}
}

using namespace std;
using namespace oi;

typedef long long ll;
typedef unsigned long long ull;

const int N = 2e5 + 10, M = N << 1;
const int INF = 0x3f3f3f3f;

int n, m, root, mod;
int h[N], ne[M], e[M], w[M], idx;
int id[N], nw[N], cnt;
int dep[N], top[N], sz[N], fa[N], son[N];

struct Segment_Tree{
	int l, r;
	ll add, sum;
}tr[N << 2];

void init(){
	memset(h, -1, sizeof h);
}

inline void add(int a, int b){
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs1(int u, int father, int depth){
	dep[u] = depth, fa[u] = father, sz[u] = 1;
	for(int i = h[u]; ~i; i = ne[i]){
		int j = e[i];
		if(j == father) continue;
		dfs1(j, u, depth + 1);
		sz[u] += sz[j];
		if(sz[son[u]] < sz[j]) son[u] = j;
	}
}

void dfs2(int u, int t){
	id[u] = ++cnt, nw[cnt] = w[u], top[u] = t;
	if(!son[u]) return;
	dfs2(son[u], t);
	for(int i = h[u]; ~i; i = ne[i]){
		int j = e[i];
		if(j == son[u] || j == fa[u]) continue;
		dfs2(j, j);
	}
}

inline void pushup(int u){
	tr[u].sum = tr[u << 1].sum  + tr[u << 1 | 1].sum;
}

inline void pushdown(int u){
	if(tr[u].add){
		Segment_Tree &root = tr[u], &le = tr[u << 1], &ri = tr[u << 1 | 1];
		le.add += root.add;
		ri.add += root.add;
		le.sum += root.add * (le.r - le.l + 1);
		ri.sum += root.add * (ri.r - ri.l + 1);
		root.add = 0;
	}
}

void build(int u, int l, int r){
	tr[u] = {l, r, 0, nw[l]};
	if(l == r) return;
	
	int mid = (l + r) >> 1;
	build(u << 1, l, mid);
	build(u << 1 | 1, mid + 1, r);
	pushup(u);
}

void update(int u, int l, int r, int c){
	if(l <= tr[u].l && tr[u].r <= r){
		tr[u].add += c;
		tr[u].sum += c * (tr[u].r - tr[u].l + 1);
		return;
	}
	
	pushdown(u);
	int mid = (tr[u].l + tr[u].r) >> 1;
	if(l <= mid) update(u << 1, l, r, c);
	if(r > mid) update(u << 1 | 1, l, r, c);
	pushup(u);
}

ll query(int u, int l, int r){
	if(l <= tr[u].l && tr[u].r <= r){
		return tr[u].sum;
	}
	
	pushdown(u);
	int mid = (tr[u].l + tr[u].r) >> 1;
	ll res = 0;
	if(l <= mid) res += query(u << 1, l, r);
	if(r > mid) res += query(u << 1 | 1, l, r);
	return res;
}

void update_path(int u, int v, int k){
	while(top[u] != top[v]){
		if(dep[top[u]] < dep[top[v]]) swap(u, v);
		update(1, id[top[u]], id[u], k);
		u = fa[top[u]];
	}
	if(dep[u] < dep[v]) swap(u, v);
	update(1, id[v], id[u], k);
}

void update_tree(int u, int k){
	update(1, id[u], id[u] + sz[u] - 1, k);
}

ll query_path(int u, int v){
	ll res = 0;
	while(top[u] != top[v]){
		if(dep[top[u]] < dep[top[v]]) swap(u, v);
		res += query(1, id[top[u]], id[u]);
		u = fa[top[u]];
	}
	if(dep[u] < dep[v]) swap(u, v);
	res += query(1, id[v], id[u]);
	return res;
}

int main(){
//	freopen("P3178_2.in", "r", stdin);
//	freopen("P3178_2.ans", "w", stdout);
	init();
	read(n, m);
	for(int i = 1; i <= n; ++i) read(w[i]);
	int a, b;
	for(int i = 1; i < n; ++i){
		read(a, b);
		add(a, b), add(b, a);
	}
	
	dfs1(1, -1, 1);
	dfs2(1, 1);
	build(1, 1, n);
	
	int op, u, k;
	while(m--){
		read(op, u);
		if(op == 1){
			read(k);
			update_path(u, u, k);
		}
		else if(op == 2){
			read(k);
			update_tree(u, k);
		}
		else{
			printf("%lld\n", query_path(1, u));
		}
	}
	
	return 0;
}