#include <fstream>
#include <algorithm>
#include <vector>

using namespace std;

vector<int>G[100010];
vector<int>L[100010];
bool viz[100010];
int arb[500010], Level[100010], fii[100010], Path[100010], Front[100010], v[100010], Dim[100010];
int N, p, val, x, y, a, b, n, m, i, j, t, Paths, Pos[100010], tata[100010];
vector<int>::iterator itl;

void update(int Which, int nod, int l, int r)
{
    if(l == r)
    {
        arb[Which+nod] = val;
        return;
    }
    int m = (l+r)/2;
    if(x <= m) update(Which, 2*nod, l, m);
    if(x > m) update(Which, 2*nod+1, m+1, r);
    arb[Which + nod] = max(arb[Which + 2*nod], arb[Which + 2*nod+1]);
}

int query(int Which, int nod, int l, int r)
{
    if(a <= l and r <= b)
    {
        return arb[Which+nod];
    }
    int m = (l+r)/2, sol = 0;
    if(a <= m) sol = max(sol, query(Which, 2*nod, l, m));
    if(b > m) sol = max(sol, query(Which, 2*nod+1, m+1, r));
    return sol;
}

void HeavyPath(int x, int level)
{
    int lant = 0;
    vector<int>::iterator it;
    Level[x] = level;
    viz[x] = 1;
    fii[x] = 1;
    for(it = G[x].begin(); it != G[x].end(); ++it)
    if(!viz[*it])
    {
        tata[*it] = x;
        HeavyPath(*it, level+1);
        fii[x] += fii[*it];
        if(fii[*it] > fii[lant]) lant = *it;
    }
    if(!lant)
        Path[x] = ++Paths;
    else
        Path[x] = Path[lant];
    L[Path[x]].push_back(x);
    Front[Path[x]] = x;
}

int main()
{
    int sol = 0;
    ifstream fi("heavypath.in");
    ofstream fo("heavypath.out");
    fi >> n >> m;
    for(i = 1; i <= n; i++) fi >> v[i];
    for(i = 1; i < n; i++)
    {
        fi >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    HeavyPath(1, 1);
    for(i = 1; i <= Paths; i++)
    {
        N = L[i].size();
        reverse(L[i].begin(), L[i].end());
        Dim[i] = Dim[i-1] + 4*N;
        for(itl = L[i].begin(), p = 1; itl != L[i].end(); ++itl, ++p)
        {
            Pos[*itl] = p;
            val = v[*itl]; x = p;
            update(Dim[i-1], 1, 1, N);
        }
    }
    while(m--)
    {
        fi >> t >> x >> y;
        if(t == 0)
        {
            i = Path[x];
            x = Pos[x];
            val = y;
            N = L[i].size();
            update(Dim[i-1], 1, 1, N);
            continue;
        }
        else
        {
            sol = 0;
            while(Path[x] != Path[y])
            {
                i = Path[x]; j = Path[y];
                if(Level[Front[i]] < Level[Front[j]])
                {
                    swap(x, y);
                    swap(i, j);
                }
                a = 1; b = Pos[x];
                N = L[i].size();
                sol = max(sol, query(Dim[i-1], 1, 1, N));
                x = tata[Front[i]];
            }
            if(Pos[x] > Pos[y]) swap(x, y);
            a = Pos[x]; b = Pos[y];
            i = Path[x]; N = L[i].size();
            sol = max(sol, query(Dim[i-1], 1, 1, N));
            fo << sol << "\n";
        }
    }

    return 0;
}