#include <bits/stdc++.h>
#define maxN 100002
#define pb push_back
#define inf 1
using namespace std;
int n, m, sol, S[maxN], v[maxN], w[maxN], f[maxN], npath, root, lev[maxN], F[maxN], pos[maxN], len[maxN];
vector < int > V[maxN], W[maxN];
int Max(int x, int y)
{
    if (x > y)
        return x;
    return y;
}
int Min(int x, int y)
{
    if (x < y)
        return x;
    return y;
}
class st
{
public :
    vector < int > aint;
    inline void update(int node, int l, int r, int p, int val)
    {
        if (l > r)
            return;
        if (l == r)
        {
            aint[node] = val;
            return ;
        }
        int lson = 2 * node, rson = lson + 1, mid = (l + r) >> 1;
        if (p <= mid)
            update(lson, l, mid, p, val);
        else
            update(rson, mid + 1, r, p, val);
        aint[node] = max(aint[lson], aint[rson]);
    }
    inline int query(int node, int l, int r, int x, int y)
    {
        if (l > r)
            return -inf;
        if (l == x && r == y)
            return aint[node];
        int lson = 2 * node, rson = lson + 1, mid = (l + r) >> 1;
        if (y <= mid)
            return query(lson, l, mid, x, y);
        else
        {
            if (x > mid)
                return query(rson, mid + 1, r, x, y);
            else
                return Max(query(lson, l, mid, x, mid), query(rson, mid + 1, r, mid + 1, y));
        }
    }
} trees[maxN];
void read()
{
    int i, x, y;
    freopen("heavypath.in", "r", stdin);
    scanf("%d %d", &n, &m);
    for (i = 1; i <= n; ++ i)
        scanf("%d", &v[i]);
    for (i = 1; i < n; ++ i)
    {
        scanf("%d %d", &x, &y);
        if (f[y])
            swap(x, y);
        V[x].pb(y);
        f[y] = x;
    }
    for (i = 1; i <= n; ++ i)
        if (!f[i])
        {
            root = i;
            break;
        }
    if (!root)
        exit(0);
}
void dfs(int x)
{
    int i, p = 0;
    for (i = 0; i < V[x].size(); ++ i)
    {
        lev[V[x][i]] = lev[x] + 1;
        dfs(V[x][i]);
        S[x] += S[V[x][i]];

        if (S[V[x][i]] > S[p])
            p = V[x][i];
        F[w[V[x][i]]] = x;
    }
    if (!p)
    {
        S[x] = 1;
        W[++ npath].pb(x);
        w[x] = npath;
        pos[x] = 1;
    }
    else
    {
        F[w[p]] = 0;
        W[w[p]].pb(x);
        w[x] = w[p];
        pos[x] = pos[p] + 1;
    }
}
void heavy_path()
{
    int i, j;
    for (i = 1; i <= npath; ++ i)
    {
        len[i] = W[i].size();
        trees[i].aint.resize(4 * len[i]);
        for (j = 0; j < len[i]; ++ j)
            trees[i].update(1, 1, len[i], j + 1, v[W[i][j]]);
    }
}
void solve()
{
    lev[root] = 1;
    dfs(root);
    heavy_path();
}
void write()
{
    int a, b, t, x, y;
    freopen("heavypath.out", "w", stdout);
    while (m --)
    {
        scanf("%d %d %d", &t, &x, &y);
        if (t == 0)
            trees[w[x]].update(1, 1, len[w[x]], pos[x], y);
        else
        {
            sol = -1;
            while (w[x] != w[y])
            {
                if (lev[F[w[x]]] < lev[F[w[y]]])
                    swap(x, y);
                sol = Max(sol, trees[w[x]].query(1, 1, len[w[x]], pos[x], len[w[x]]));
                x = F[w[x]];
            }
            a = Min(pos[x], pos[y]);
            b = Max(pos[x], pos[y]);
            sol = Max(sol, trees[w[x]].query(1, 1, len[w[x]], a, b));
            printf("%d\n", sol);
        }
    }
}
int main()
{
    read();
    solve();
    write();
    return 0;
}