#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 2e5 + 5;
int n, m, r, p;
int w[N];
int fa[N], dep[N], id[N], top[N], son[N], cnt, size[N], a[N];
vector<int> g[N];

struct Segment_Tree
{
	struct node
	{
		int l, r, sum, lazy;
	}tr[N << 2];
	void push_up(int u)
	{
		tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
	}
	void build(int u, int l, int r)
	{
		tr[u].l = l, tr[u].r = r;
		if(l == r){
			tr[u].sum = a[l]; tr[u].sum %= p;
			return ;
		}
		int mid = (l + r) >> 1;
		build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
		push_up(u);
	}
	void update(int u, int l, int r, int k)
    {
        if(l <= tr[u].l && tr[u].r <= r){
            tr[u].lazy += k;
            return ;
        }
        tr[u].sum += (min(r, tr[u].r) - max(l, tr[u].l) + 1) * k;
        int mid = (tr[u].l + tr[u].r) >> 1;
        if(l <= mid) update(u << 1, l, r, k);
        if(r >  mid) update(u << 1 | 1, l, r, k);
    }
	int query(int u, int l, int r)
	{
		if(l <= tr[u].l && tr[u].r <= r)
		{
			return (tr[u].sum + (tr[u].r - tr[u].l + 1) * tr[u].lazy) % p;
		}
		int res = (min(tr[u].r, r) - max(tr[u].l, l) + 1) * tr[u].lazy;
		int mid = (tr[u].l + tr[u].r) >> 1;
		if(l <= mid) res += query(u << 1, l, r);
		if(r >  mid) res += query(u << 1 | 1, l, r);
		return res % p;
	}
}seg;

void dfs1(int u, int f, int deep)
{
    dep[u] = deep;
    fa[u] = f;
    size[u] = 1;
    int maxn = -1;
    for(int i = 0;i < g[u].size();i ++ )
    {
        int v = g[u][i];
        if(v == f) continue;
        dfs1(v, u, deep + 1);
        size[u] += size[v];
        if(size[v] > maxn) {
            maxn = size[v];
            son[u] = v;
        }
    }
}

struct TreePou
{
	void update(int x, int y, int val)
	{
		val %= p;
		while(top[x] != top[y]){
			if(dep[top[x]] < dep[top[y]]) swap(x, y);
			seg.update(1, id[top[x]], id[x], val);
			x = fa[top[x]];
		}
		if(dep[x] > dep[y]) swap(x, y);
		seg.update(1, id[x], id[y], val);
	}
	int query(int x, int y)
	{
		int ans = 0;
		while(top[x] != top[y]){
			if(dep[top[x]] < dep[top[y]]) swap(x, y);
			ans += seg.query(1, id[top[x]], id[x]);
			ans %= p;
			x = fa[top[x]];
		}
		if(dep[x] > dep[y]) swap(x, y);
		ans += seg.query(1, id[x], id[y]);
		return ans % p;	
	}
	void tupdate(int x, int y)
	{
		seg.update(1, id[x], id[x] + size[x] - 1, y);
	}
	int tquery(int x)
	{
		return seg.query(1, id[x], id[x] + size[x] - 1);
	}
}tp;

void dfs2(int u, int topfa)
{
    id[u] = ++cnt;
    top[u] = topfa;
    a[cnt] = w[u];
    if(!son[u]) return ;
    dfs2(son[u], topfa);
    for(int i = 0;i < g[u].size();i ++ ){
        int v = g[u][i];
        if(v == fa[u] || v == son[u]){
            continue;
        }
        dfs2(v, v);
    }
}

signed main()
{   
    cin >> n >> m;
    r = 1, p = INT_MAX;
    for(int i = 1;i <= n;i ++ ) cin >> w[i];
    for(int i = 1;i < n;i ++ )
    {
        int x, y; cin >> x >> y;
        g[x].push_back(y), g[y].push_back(x);
    }
    dfs1(r, 0, 1);
    dfs2(r, r);
    seg.build(1, 1, n);
    while(m -- )
    {
        int op, x, y, z;
        cin >> op;
        if(op == 1)
        {
            cin >> x >> z;
            tp.update(x, x, z);
        }
        else if(op == 2)
        {
            cin >> x >> y;
             tp.tupdate(x, y) ;
        }
        else if(op == 3)
        {
        	cin >> x;
            cout << tp.query(1, x) << endl;
        }
    }
    return 0;
}