#include <bits/stdc++.h>
	
 
	
using namespace std;
	
int N, M;
	
const int INF = 0x3f3f3f3f;
	
const int Nmax = 100005;
	
 
	
vector<int> G[Nmax];
	
vector<int> lant[Nmax];
	
bitset<Nmax> used;
	
 
	
int care_lant[Nmax];
	
int tata_lant[Nmax];
	
int poz_lant[Nmax];
	
int greutate[Nmax];
	
int adancime[Nmax];
	
int valori[Nmax];
	
 
	
 
	
int pos, newX, A, B, answer, LC;
	
int nrl = 1;
	
 
	
class cmp{
	
public:
	
    bool operator()(const int &v1, const int &v2) const {
	
        return greutate[v1] > greutate[v2];
	
    }
	
};
	
 
	
class SegmentTree{
	
public:
	
    vector<int> range;
	
    void resize(int k) {
	
        range.resize(4 * k);
	
    }
	
    void build(int li, int lf ,int pz) {
	
        if(li == lf) {
	
            range[pz] = valori[lant[LC][li]];
	
            return;
	
        }
	
        int m = li + ((lf - li) >> 1);
	
        build(li, m , pz << 1);
	
        build(m + 1, lf, (pz << 1) | 1);
	
        range[pz] = max(range[pz << 1], range[(pz << 1) | 1]);
	
    }
	
    void update(int li, int lf, int pz) {
	
        if(li == lf) {
	
            range[pz] = newX;
	
            return;
	
        }
	
        int m = li + ((lf - li) >> 1);
	
        if(pos <= m)
	
            update(li, m, pz << 1);
	
        else
	
            update(m + 1, lf, (pz << 1) | 1);
	
 
	
        range[pz] = max(range[pz << 1], range[(pz << 1) | 1]);
	
    }
	
    void query(int li ,int lf, int pz) {
	
        if(A <= li && lf <= B) {
	
            answer = max(answer, range[pz]);
	
            return;
	
        }
	
        int m = li + ((lf - li) >> 1);
	
        if(A <= m)
	
            query(li, m, pz << 1);
	
        if(m < B)
	
            query(m + 1, lf, (pz << 1) | 1);
	
    }
	
};
	
SegmentTree Aint[Nmax];
	
 
	
void read()
	
{
	
    scanf("%d%d", &N, &M);
	
    for(int i = 1; i <= N; ++i){
	
        scanf("%d", &valori[i]);
	
    }
	
    for(int i = 1; i < N; ++i){
	
        int a, b;
	
        scanf("%d%d", &a, &b);
	
        G[a].push_back(b);
	
        G[b].push_back(a);
	
    }
	
}
	
 
	
void get_weight(int k)
	
{
	
    used[k] = 1;
	
    greutate[k] = 1;
	
    for(auto it : G[k])
	
        if(!used[it]) {
	
            adancime[it] = adancime[k] + 1;
	
            get_weight(it);
	
            greutate[k] += greutate[it];
	
        }
	
}
	
 
	
void descomp(int k)
	
{
	
    used[k] = 1;
	
    lant[nrl].push_back(k);
	
    care_lant[k] = nrl;
	
    poz_lant[k] = lant[nrl].size() - 1;
	
    for(auto it : G[k])
	
        if(!used[it]){
	
            if(lant[nrl].back() != k) {
	
                lant[++nrl].push_back(0);
	
                tata_lant[nrl] = k;
	
            }
	
            descomp(it);
	
        }
	
}
	
 
	
void Decompose()
	
{
	
    adancime[1] = 1;
	
    get_weight(1);
	
    used = 0;
	
    for(int i = 1; i <= N; ++i)
	
        sort(G[i].begin(), G[i].end(), cmp());
	
    lant[nrl].push_back(0);
	
    descomp(1);
	
}
	
 
	
void Build_trees()
	
{
	
    for(LC = 1; LC <= nrl; ++LC) {
	
        Aint[LC].resize(lant[LC].size());
	
        Aint[LC].build(1, lant[LC].size() - 1, 1);
	
    }
	
}
	
 
	
int Search(int x, int y)
	
{
	
    answer = -INF;
	
    while(care_lant[x] != care_lant[y])
	
    {
	
        if(adancime[tata_lant[care_lant[x]]] < adancime[tata_lant[care_lant[y]]])
	
            swap(x,y);
	
        if(care_lant[x] == 1)
	
            swap(x,y);
	
        LC = care_lant[x];
	
        A = 1;
	
        B = poz_lant[x];
	
        Aint[LC].query(1, lant[LC].size() - 1, 1);
	
        x = tata_lant[LC];
	
    }
	
    A = poz_lant[x];
	
    B = poz_lant[y];
	
    LC = care_lant[x];
	
    if(A > B) swap(A,B);
	
    Aint[LC].query(1, lant[LC].size() - 1, 1);
	
    return answer;
	
}
	
 
	
void Solve()
	
{
	
    int x,y,op,ch;
	
    for(int i = 1; i <= M; ++i) {
	
        scanf("%d%d%d", &op, &x, &y);
	
        if(op == 0)
	
        {
	
            LC = care_lant[x];
	
            newX = y;
	
            pos = poz_lant[x];
	
            Aint[LC].update(1, lant[LC].size() - 1, 1);
	
        }
	
        else
	
            printf("%d\n", Search(x,y));
	
    }
	
}
	
 
	
int main()
	
{
	
    freopen("heavypath.in", "r", stdin);
	
    freopen("heavypath.out", "w", stdout);
	
 
	
    read();
	
    Decompose();
	
    Build_trees();
	
    Solve();
	
 
	
    return 0;
	
}