#include <bits/stdc++.h>

using namespace std;

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

vector<int> g[kNmax];
int depth[kNmax];
int v[kNmax];
int father[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[x] = f;

    subtree_size[x] = 1;

    int heaviest = -1; 
    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 (heaviest == -1 || 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;

    if (!g[x].empty() && g[x][0] != f) {
        prv[g[x][0]] = prv[x];
        dfs_liniarization(g[x][0], x);
    }

    for (int i = 1; i < int(g[x].size()); i++) {
        int y = g[x][i];
        if (y == f) continue;
        prv[y] = y;
        dfs_liniarization(y, 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 query(int x, int y) {
    int init = -1;

    while (prv[x] != prv[y]) {
        if (depth[prv[x]] < depth[prv[y]])
            swap(x, y);

        init = max(init, _query(1, 1, n, fst[prv[x]], fst[x]));
        x = father[prv[x]];
    }
    if (depth[x] < depth[y]) swap(x, y);
    init = max(init, _query(1, 1, n, fst[y], fst[x]));

    return init;
}

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

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    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;
}