#include <bits/stdc++.h>

using namespace std;

const long long NR = 2e5 + 1;
const int oo = 1e9;
int d[NR], parent[NR], lvl[NR], eulerTour[NR << 1], lg[NR << 1], firstAp[NR], aIntPos[NR];
int n, m, eulerCounter, aIntCounter = -1;
int rmq[20][NR], weight[NR], aIntChain[NR];
vector<int> v[NR], aInt[NR];

void dfs(int nod, int prt) {
    eulerTour[++eulerCounter] = nod;
    firstAp[nod] = eulerCounter;
    parent[nod] = prt;
    lvl[nod] = 1 + lvl[prt];
    weight[nod] = 1;
    int heaviest = -1, bestWeight = -1;
    for (auto it : v[nod]) {
        if (it == prt) {
            continue;
        }
        dfs(it, nod);
        eulerTour[++eulerCounter] = nod;
        weight[nod] += weight[it];
        if (weight[it] > bestWeight) {
            bestWeight = weight[it];
            heaviest = it;
        }
    }
    if (heaviest == -1) {
        ++aIntCounter;
        aInt[aIntCounter].emplace_back(nod);
        aIntPos[nod] = (int) aInt[aIntCounter].size() - 1;
        aIntChain[nod] = aIntCounter;
    } else {
        aInt[aIntChain[heaviest]].emplace_back(nod);
        aIntPos[nod] = (int) aInt[aIntChain[heaviest]].size() - 1;
        aIntChain[nod] = aIntChain[heaviest];
    }
}

inline void compute() {
    for (int i = 1; i <= eulerCounter; ++i) {
        i > 1 ? lg[i] = 1 + lg[i >> 1] : int();
        rmq[0][i] = eulerTour[i];
    }
    for (int i = 1; (1 << i) <= eulerCounter; ++i) {
        for (int j = 1; j + (1 << i) <= eulerCounter + 1; ++j) {
            rmq[i][j] = (lvl[rmq[i - 1][j]] < lvl[rmq[i - 1][j + (1 << (i - 1))]]) ? rmq[i - 1][j] : rmq[i - 1][j + (1
                    << (i - 1))];
        }
    }
}

inline int lcaQuery(int x, int y) {
    x = firstAp[x];
    y = firstAp[y];
    x > y ? swap(x, y) : void();
    int logg = lg[y - x + 1];
    return lvl[rmq[logg][x]] < lvl[rmq[logg][y - (1 << logg) + 1]] ? rmq[logg][x] : rmq[logg][y - (1 << logg) + 1];
}

int getMax(int chain, int st, int dr) {
    int maxi = d[aInt[chain][st]];
    for (int i = st + 1; i <= dr; ++i) {
        maxi = max(maxi, d[aInt[chain][i]]);
    }
    return maxi;
}

int findMaximum(int x, int y) {
    int maximum = -oo;
    while (aIntChain[x] != aIntChain[y]) {
        maximum = max(maximum, getMax(aIntChain[x], aIntPos[x], (int) aInt[aIntChain[x]].size() - 1));
        x = parent[aInt[aIntChain[x]].back()];
    }
    return max(maximum, getMax(aIntChain[x], aIntPos[x], aIntPos[y]));
}

signed main() {
    ifstream in("heavypath.in");
    ofstream out("heavypath.out");
    ios::sync_with_stdio(false);
    in.tie();
    int x, y, t;
    in >> n >> m;
    for (int i = 1; i <= n; ++i) {
        in >> d[i];
    }
    for (int i = 1; i < n; ++i) {
        in >> x >> y;
        v[x].emplace_back(y);
        v[y].emplace_back(x);
    }
    dfs(1, 0);
    compute();
    for (int i = 1; i <= m; ++i) {
        in >> t >> x >> y;
        if (t == 0) {
            d[x] = y;
        } else {
            int lca = lcaQuery(x, y), res = d[lca];
            //out << max(findMaximum(x, lca), findMaximum(y, lca)) << '\n';
            for (int j : {x, y}) {
                while (lca != j) {
                    res = max(res, d[j]);
                    j = parent[j];
                }
            }
            out << res << '\n';
            //cout << min(findMinimum(x, lca), findMaximum(y, lca)) << '\n';
            //cout << res << '\n';
        }
    }
    in.close();
    out.close();
    return 0;
}