#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;


const int MAX_N = 1e5 + 10;

int N, value[MAX_N], niv[MAX_N], nr_lanturi, weight[MAX_N], lant[MAX_N], poz[MAX_N], len[MAX_N], tatalant[MAX_N];
bool viz[MAX_N];
vector <int> G[MAX_N], arbint[MAX_N];

void dfs(int nod, int nivel){

    viz[nod] = 1;
    niv[nod] = nivel;
    if(G[nod].size() == 1 && nod != 1){

        weight[nod] = 1;
        ++nr_lanturi;
        lant[nod] = nr_lanturi;
        poz[nod] = ++len[nr_lanturi];
        return;
    }
    int nodmax = 0;
    for(int i = 0; i < (int)G[nod].size(); ++i){

        if(viz[G[nod][i]])
            continue;
        dfs(G[nod][i], nivel + 1);
        weight[nod] += weight[G[nod][i]];
        if(weight[G[nod][i]] > weight[nodmax])
            nodmax = G[nod][i];
    }
    for(int i = 0; i < (int)G[nod].size(); ++i)
        if(G[nod][i] != nodmax)
            tatalant[lant[G[nod][i]]] = nod;

    lant[nod] = lant[nodmax];
    poz[nod] = ++len[lant[nod]];

}

int ind, pozitie, val, left, right;

int max(int x, int y){

    if(x > y)
        return x;
    return y;
}

int min(int x, int y){

    if(x > y)
        return y;
    return x;
}

void update(int nod, int st, int dr){

    if(st == dr){
        arbint[ind][nod] = val;
        return;
    }
    int mij = (st + dr) >> 1;
    if(pozitie <= mij)
        update((nod << 1), st, mij);
    if(pozitie > mij)
        update((nod << 1) + 1, mij + 1, dr);
    arbint[ind][nod] = max(arbint[ind][(nod << 1)], arbint[ind][(nod << 1) + 1]);
}

int query(int nod, int st, int dr){

    if(left <= st && dr <= right)
        return arbint[ind][nod];
    int mij = (st + dr) >> 1;
    int res = 0;
    if(left <= mij)
        res = max(res, query((nod << 1), st, mij));
    if(mij < right)
        res = max(res, query((nod << 1) + 1, mij + 1, dr));
    return res;
}

int lca(int x, int y){

    int vmax = 0;
    while(lant[x] != lant[y]){

        if(niv[tatalant[lant[x]]] > niv[tatalant[lant[y]]]){

            ind = lant[x];
            left = 1;
            right = poz[x];
            vmax = max(vmax, query(1, 1, len[lant[x]]));
            x = tatalant[lant[x]];
        }
        else{
            ind = lant[y];
            left = 1;
            right = poz[y];
            vmax = max(vmax, query(1, 1, len[lant[y]]));
            y = tatalant[lant[y]];
        }
    }
    ind = lant[x];
    left = min(poz[x], poz[y]);
    right = max(poz[x], poz[y]);
    vmax = max(vmax, query(1, 1, len[lant[x]]));
    return vmax;
}


int main()
{

    freopen("heavypath.in", "r", stdin);
    freopen("heavypath.out", "w", stdout);

    int m;
    scanf("%d %d\n", &N, &m);
    for(int i = 1; i <= N; ++i)
        scanf("%d", &value[i]);
    for(int i = 1; i < N; ++i){

        int x, y;
        scanf("%d %d\n", &x, &y);
        G[x].push_back(y);
        G[y].push_back(x);
    }

    dfs(1, 1);

    for(int i = 1; i <= nr_lanturi; ++i)
        arbint[i].resize(4 * len[i] + 10);

    for(int i = 1; i <= N; ++i){

        poz[i] = len[lant[i]] + 1 - poz[i];
        ind = lant[i];
        pozitie = poz[i];
        val = value[i];
        update(1, 1, len[lant[i]]);
    }


    for(; m >= 1; --m){

        int t, x, y;
        scanf("%d %d %d\n", &t, &x, &y);
        if(t == 0){

            ind = lant[x];
            pozitie = poz[x];
            val = y;
            update(1, 1, len[lant[x]]);
        }
        else
            printf("%d\n", lca(x, y));
    }

    fclose(stdin);
    fclose(stdout);

    return 0;
}