#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

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

const int maxN = 200005;
int n, q, v[maxN], sz[maxN], depth[maxN], poz[maxN], cap[maxN], currPoz, currLant;
int s[20][maxN];
vector <int> G[maxN];
int aint[4 * maxN];

void update(int poz, int val, int nod = 1, int st = 1, int dr = n) {
    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 = 1, int st = 1, int dr = n) {
    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 dfs(int nod, int tata) {
    s[0][nod] = tata;
    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, int capat) {
    cap[nod] = capat;
    poz[nod] = ++currPoz;
    update(currPoz, v[nod]);
    int heavySon = 0;
    for (int vecin : G[nod]) {
        if (vecin == tata) {
           continue;
        }
        if (sz[vecin] > sz[heavySon])
            heavySon = vecin;
    }
    if (!heavySon)
    return;
    dfsHeavy(heavySon, nod, capat);
    for (int vecin : G[nod]) {
        if (vecin == tata || vecin == heavySon) {
           continue;
        }
        dfsHeavy(vecin, nod, vecin);
    }
}

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

int calc(int nod, int lca) {
    int ans = 0;
    while (nod != lca) {
        if (cap[nod] == nod) {
            ans = max(ans, v[nod]);
            nod = s[0][nod];
        }
        else if (depth[cap[nod]] > depth[lca]) {
            ans = max(ans, query(poz[cap[nod]], poz[nod]));
            nod = s[0][cap[nod]];
        }
        else {
            ans = max(ans, query(poz[lca], poz[nod]));
            break;
        }
    }
    return ans;
}

int main() {
    fin >> n >> q;
    for (int i = 1; i <= n; i++) {
        fin >> v[i];
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        fin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs(1, 0);
    for (int nod = 1; nod <= n; nod++) {
        for (int j = 1; j < 20; j++)
            s[j][nod] = s[j - 1][s[j - 1][nod]];
    }
    dfsHeavy(1, 0, 1);
    for (int i = 1; i <= q; i++) {
        int op;
        fin >> op;
        if (op == 0) {
            int nod, val;
            fin >> nod >> val;
            v[nod] = val;
            update(poz[nod], val, 1, 1, n);
        }
        if (op == 1) {
            int x, y;
            fin >> x >> y;
            int lca = computeLCA(x, y);
            fout << max(calc(x, lca), calc(y, lca)) << '\n';
        }
    }
    return 0;
}