#include <bits/stdc++.h>
#define N 100005
using namespace std;
typedef long long ll;

int n, m, c[N];
int dep[N], len[N], son[N], tI[N], tO[N], tmr;
vector <int> to[N];

ll buf[N*2], buf2[N*2], *f[N], *suf[N], *cur=buf, *cur2=buf2;
ll tg[N];

int B, st[N], idB[N];
ll ans[N];
vector <int> vec[N];
struct Qry { int op, x, v; } q[N];

void dfs_son (int u, int fa)
{
    for (int i=0; i<(int)to[u].size(); i++) {
        int v=to[u][i];
        if (v==fa) { continue; }
        dfs_son(v, u);
        if (len[v]>len[son[u]]) { son[u]=v; }
    }
    len[u]=len[son[u]]+1;
}
void dfs_f (int u, int fa)
{
    tI[u]=++tmr; dep[u]=dep[fa]+1;

    if (son[u]) {
        f[son[u]]=f[u]+1;
        suf[son[u]]=suf[u]+1;
        dfs_f(son[u], u);
    }
    for (int i=0; i<(int)to[u].size(); i++) {
        int v=to[u][i];
        if (v==fa || v==son[u]) { continue; }
        f[v]=cur; cur+=(len[v]+1);
        suf[v]=cur2; cur2+=(len[v]+1);
        dfs_f(v, u);
    }

    tO[u]=tmr;
}

bool up (int u, int v) { return tI[u]<=tI[v] && tO[v]<=tO[u]; }

void cal (int u, int fa, int idb)
{
    if (son[u]) {
        cal(son[u], u, idb);
    }

    f[u][0]=c[u];
    suf[u][0]=(len[u]==0 ? f[u][0] : (suf[u][1]^f[u][0]));

    for (int i=0; i<(int)to[u].size(); i++) {
        int v=to[u][i];
        if (v==fa || v==son[u]) { continue; }
        cal(v, u, idb);
        for (int j=0; j<=len[v]; j++) {
            tg[j+1]=(f[u][j+1]^(f[u][j+1]+f[v][j]));
            f[u][j+1]+=f[v][j];
        }
        tg[0]=0;
        for (int j=len[v]+1; j>=0; j--) {
            if (j<=len[v]) { tg[j]^=tg[j+1]; }
            suf[u][j]^=tg[j];
        }
    }

    for (int i=0; i<(int)vec[u].size(); i++) {
        int qid=vec[u][i], L=q[qid].v;

        if (L>=len[u]) { ans[qid]=suf[u][0]; }
        else { ans[qid]=(suf[u][0]^suf[u][L+1]); }

        for (int j=st[idb]; j<qid; j++) {
            int x=q[j].x, v=q[j].v;
            if (up(u, x) && dep[x]-dep[u]<=L) {
                ans[qid]^=(f[u][dep[x]-dep[u]]^(f[u][dep[x]-dep[u]]-c[x]+v));
            }
        }
    }
}

void solve ()
{
    len[0]=-1; dfs_son(1, 0);

    f[1]=cur; cur+=(len[1]+1);
    suf[1]=cur2; cur2+=(len[1]+1);
    dfs_f(1, 0);

    for (int i=1; i<=m; i=st[idB[i]+1]) {
        for (int u=1; u<=n; u++) { vec[u].clear(); }
        fill(buf, cur, 0);
        fill(buf2, cur2, 0);

        for (int j=i; j<st[idB[i]+1]; j++) {
            if (q[j].op==2) { vec[q[j].x].push_back(j); }
        }

        cal(1, 0, idB[i]);

        for (int j=i; j<st[idB[i]+1]; j++) {
            if (q[j].op==1) { c[q[j].x]=q[j].v; }
        }
    }

    for (int i=1; i<=m; i++) if (q[i].op==2) { printf("%lld\n", ans[i]); }
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d %d", &n, &m);
    for (int i=1; i<=n; i++) { scanf("%d", &c[i]); }
    for (int i=1; i<n; i++) {
        int u, v; scanf("%d %d", &u, &v);
        to[u].push_back(v);
        to[v].push_back(u);
    }
    for (int t=1; t<=m; t++) {
        scanf("%d %d %d", &q[t].op, &q[t].x, &q[t].v);
    }
    B=ceil(sqrt(m));

    for (int i=1; i<=m; i++) {
        idB[i]=((i-1)/B)+1;
        if (!st[idB[i]]) { st[idB[i]]=i; }
    }
    st[idB[m]+1]=m+1;

    solve();

    return 0;
}