#include <bits/stdc++.h>

using namespace std;

ifstream in("heavypath.in");
ofstream out("heavypath.out");

int n, m, pz, nrCh, qpoz, qval, start, finish;
int val[100001], sz[100001], level[100001], tata[100001];
int chain[100001], poz[100001], varf[100001];
int aint[400001];
vector <int> g[100001];

inline void DFS0(int nod, int pr) {
    sz[nod] = 1;
    for (auto vecin : g[nod]) {
        if (vecin != pr) {
            tata[vecin] = nod;
            level[vecin] = level[nod] + 1;
            DFS0(vecin, nod);
            sz[nod] += sz[vecin];
        }
    }
    for (int i = 0; i < g[nod].size(); ++i) {
        if (g[nod][i] == pr) {
            swap(g[nod][i], g[nod].back());
            g[nod].pop_back();
        }
    }
}

inline void update(int nod, int st, int dr) {
    if (st == dr) {
        aint[nod] = qval;
        return;
    }
    int mid = (st + dr) >> 1;
    if (qpoz <= mid)
        update(2 * nod, st, mid);
    else
        update(2 * nod + 1, mid + 1, dr);
    aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
}

inline int query(int nod, int st, int dr) {
    if (start <= st && dr <= finish)
        return aint[nod];
    int ans = 0, mid = (st + dr) >> 1;
    if (start <= mid)
        ans = max(ans, query(2 * nod, st, mid));
    if (mid < finish)
        ans = max(ans, query(2 * nod + 1, mid + 1, dr));
    return ans;
}

inline int heavyQuery(int x, int y) {
    int ans = 0;
    while (chain[x] != chain[y]) {
        if (level[varf[chain[x]]] < level[varf[chain[y]]])
            swap(x, y);
        start = poz[x], finish = poz[varf[chain[x]]];
        ans = max(ans, query(1, 1, n));
        x = tata[varf[chain[x]]];
    }
    if (level[x] < level[y])
        swap(x, y);
    start = poz[x], finish = poz[y];
    ans = max(ans, query(1, 1, n));
    return ans;
}

inline bool cmp(int a, int b) {
    return sz[a] < sz[b];
}

inline void decompose(int nod) {
    sort(g[nod].begin(), g[nod].end(), cmp);
    for (auto vecin : g[nod])
        decompose(vecin);
    chain[nod] = (g[nod].empty() ? ++nrCh : chain[g[nod].back()]);
    varf[chain[nod]] = nod;
    poz[nod] = ++pz;
    qpoz = poz[nod], qval = val[nod];
    update(1, 1, n);
}

int main() {
    in >> n >> m;
    for (int i = 1; i <= n; ++i)
        in >> val[i];
    for (int x, y, i = 1; i < n; ++i) {
        in >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    tata[1] = 1;
    level[1] = 1;
    DFS0(1, 0);
    decompose(1);
    while (m--) {
        int t, x, y;
        in >> t >> x >> y;
        if (!t) {
            qpoz = poz[x], qval = y;
            update(1, 1, n);
        } else
            out << heavyQuery(x, y) << '\n';
    }
    return 0;
}