#include <bits/stdc++.h>

using namespace std;

const int kNmax = 1e5+5;
const int kLogNmax = 18;

vector<int> g[kNmax];
int depth[kNmax];
int father[kLogNmax][kNmax];
int subtree_size[kNmax];
int fst[kNmax];
int prv[kNmax];
int liniarization[kNmax];

void dfs_precalc(int x, int f = 0) {
    depth[x] = depth[f] + 1;
    father[0][x] = f;
    for (int k = 1; k < kLogNmax; k++)
        father[k][x] = father[k - 1][father[k - 1][x]];

    subtree_size[x] = 1;

    int heaviest = 0; 
    for (int i = 0; i < int(g[x].size()); i++) {
        int y = g[x][i];
        if (y == f) continue;
        dfs_precalc(y, x);
        subtree_size[x] += subtree_size[y];
        if (subtree_size[y] > subtree_size[g[x][heaviest]])
            heaviest = i;
    }

    if (heaviest > 0) swap(g[x][heaviest], g[x][0]);
}

int pos = 0;

void dfs_liniarization(int x, int f = 0) {
    liniarization[++pos] = x;
    fst[x] = pos;

    for (int i = 0; i < int(g[x].size()); i++) {
        int y = g[x][i];
        if (y == f) continue;
        if (i == 0)
            prv[y] = prv[x];
        else
            prv[y] = y;
        dfs_liniarization(y, x);
    }
}

int lca(int x, int y) {
    if (depth[x] < depth[y]) swap(x, y);

    for (int k = kLogNmax - 1; k >= 0; --k) {
        if (depth[x] - (1<<k) >= depth[y])
            x = father[k][x];
    }

    if (x == y) return x;

    for (int k = kLogNmax - 1; k >= 0; --k) {
        if (father[k][x] != 0 && father[k][x] != father[k][y])
            x = father[k][x], y = father[k][y];
    }

    return father[0][x];
}

int aint[4 * kNmax];

void _update(int n, int l, int r, int pos, int val) {
    if (l == r) {
        aint[n] = val;
        return;
    }

    int m = (l + r) / 2;
    if (pos <= m)
        _update(2 * n, l, m, pos, val);
    else
        _update(2 * n + 1, m + 1, r, pos, val);
    aint[n] = max(aint[2*n], aint[2*n+1]);
}

int n, m;

void update(int x, int y) {
    _update(1, 1, n, x, y);
}

int _query(int n, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr) return aint[n];
    if (qr < l) return -1;
    if (r < ql) return -1;

    int m = (l + r) / 2;
    return max(_query(2 * n, l, m, ql, qr), _query(2 * n + 1, m + 1, r, ql, qr));
}

int hpd_query_chain(int x, int z) {
    int init = -1;

    while (depth[x] >= depth[z]) {
        if (depth[prv[x]] <= depth[z]) {
            return max(init, _query(1, 1, n, fst[z], fst[x]));
        }

        init = max(init, _query(1, 1, n, fst[prv[x]], fst[x]));
        x = father[0][prv[x]];
    }

    assert(false);
}

int query(int x, int y) {
    int z = lca(x, y);
    return max(hpd_query_chain(x, z), hpd_query_chain(y, z));
}

int main() {
#ifdef INFOARENA
    ifstream cin("heavypath.in");
    ofstream cout("heavypath.out");
#endif

    cin >> n >> m;
    vector<int> v(n + 1, 0);
    for (int i = 1; i <= n; i++) cin >> v[i];
    for (int x, y, i = 1; i < n; i++) {
        cin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }

    prv[1] = 1;
    dfs_precalc(1);
    dfs_liniarization(1);
    for (int i = 1; i <= n; i++) update(fst[i], v[i]);
    for (int i = 1, t, x, y; i <= m; i++) {
        cin >> t >> x >> y;
        if (t == 1)
            cout << query(x, y) << '\n';
        else
            update(fst[x], y);
    }
    return 0;
}