#include <iostream>
#include <vector>
 
using namespace std;
 
const int maxN = 100005;
int n, q, v[maxN], sz[maxN], depth[maxN], lantSize[maxN], lant[maxN], pozLant[maxN], cap[maxN], currLant;
int s[20][maxN];
vector <int> G[maxN];

struct SegTree {
    int sz;
    vector <int> aint;
    void update(int poz, int val, int nod, int st, int dr) {
        if (st == dr) {
            aint[nod] = val;
            return;
        }
        int med = (st + dr) / 2;
        if (poz <= med) {
            update(poz, val, 2 * nod, st, med);
        }
        else
            update(poz, val, 2 * nod + 1, med + 1, dr);
        aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
    }
    int query(int qst, int qdr, int nod, int st, int dr) {
        if (st == dr) {
            return aint[nod];
        }
        int med = (st + dr) / 2, maxi = 0;
        if (qst <= med) {
            maxi = max(maxi, query(qst, qdr, 2 * nod, st, med));
        }
        if (med < qdr) {
            maxi = max(maxi, query(qst, qdr, 2 * nod + 1, med + 1, dr));
        }
        return maxi;
    }
    void init(int N) {
        sz = N;
        aint.resize(4 * sz + 1);
    }
};
vector <SegTree> T;

void dfs(int nod, int tata) {
    s[0][nod] = tata;
    for (int i = 1; i < 20; i++) {
        s[i][nod] = s[i - 1][s[i - 1][nod]];
    }
    sz[nod] = 1;
    depth[nod] = depth[tata] + 1;
    for (int vecin : G[nod]) {
        if (vecin == tata) {
            continue;
        }
        dfs(vecin, nod);
        sz[nod] += sz[vecin];
    }
}

void dfsHeavy(int nod, int tata) {
    if (2 * sz[nod] >= sz[tata]) {
        lant[nod] = lant[tata];
        lantSize[lant[nod]]++;
        pozLant[nod] = pozLant[tata] + 1;
    }
    else {
        lant[nod] = ++currLant;
        lantSize[currLant]++;
        pozLant[nod] = 1;
        cap[currLant] = nod;
    }
    for (int vecin : G[nod]) {
        if (vecin == tata) {
           continue;
        }
        dfsHeavy(vecin, nod);
    }
}

int computeLCA(int x, int y) {
    if (depth[x] > depth[y])
        swap(x, y);
    int diff = depth[y] - depth[x];
    for (int i = 19; i >= 0; i--) {
        if (diff & (1 << i)) {
            y = s[i][y];
        }
    }
    if (x == y)
        return x;
    for (int i = 19; i >= 0; i--) {
        if (s[i][x] != s[i][y]) {
            x = s[i][x];
            y = s[i][y];
        }
    }
    return s[0][x];
}

int query(int nod, int lca) {
    if (lant[nod] == lant[lca]) {
        return T[lant[nod]].query(pozLant[lca], pozLant[nod], 1, 1, lantSize[lant[nod]]);
    }
    return max(T[lant[nod]].query(1, pozLant[nod], 1, 1, lantSize[lant[nod]]), query(s[0][cap[lant[nod]]], lca));
}

int main() {
    #ifdef LOCAL
        freopen("test.in", "r", stdin);
        freopen("test.out", "w", stdout);
    #endif // LOCAL
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs(1, 0);
    dfsHeavy(1, 0);
    T.resize(currLant + 1);
    for (int i = 0; i <= currLant; i++) {
        T[i].init(lantSize[i]);
    }
    for (int i = 1; i <= n; i++) {
        T[lant[i]].update(pozLant[i], v[i], 1, 1, lantSize[lant[i]]);
    }
    for (int i = 1; i <= q; i++) {
        int op;
        cin >> op;
        if (op == 0) {
            int nod, val;
            cin >> nod >> val;
            v[nod] = val;
            T[lant[nod]].update(pozLant[nod], v[nod], 1, 1, lantSize[lant[nod]]);
        }
        if (op == 1) {
            int x, y;
            cin >> x >> y;
            int lca = computeLCA(x, y);
            cout << max(query(x, lca), query(y, lca)) << '\n';
        }
    }
    return 0;
}