#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

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

#define MAXN 100000 + 5

int lg[MAXN];

void calc() {
    int log = 0;
    int next = 2;
    for (int i = 1; i <= MAXN; ++i) {
        if (i == next) {
            log++;
            next *= 2;
        }
        lg[i] = log;
    }
}

int  putere(int n, int p)
{
    if(p==0)
        return 1;
    if(p%2!=0)
        return n*putere(n, p-1);
    return putere((n*n), p/2);

}

class SegmentTree {
public:
    int n;
    int* tree;

    SegmentTree(int size) {
        n = size;
        int nodes = putere(2, lg[n] + 1);
        tree = new int[nodes + 1]();
    }

    void build(int id, int start, int end, vector<int> &path, int* v) {
        if (start == end) {
            tree[id] = v[path[start - 1]];
            return;
        }

        int mid = (start + end) / 2;
        build(id * 2, start, mid, path, v);
        build(id * 2 + 1, mid + 1, end, path, v);
        tree[id] = max(tree[id * 2], tree[id * 2 + 1]);
    }

    void update(int id, int start, int end, int pos, int val) {
        if (start > pos || end < pos) return;

        if (start == end) {
            tree[id] = val;
            return;
        }

        int mid = (start + end) / 2;
        update(id * 2, start, mid, pos, val);
        update(id * 2 + 1, mid + 1, end, pos, val);
        tree[id] = max(tree[id * 2], tree[id * 2 + 1]);
    }

    int query(int id, int start, int end, int a, int b) {
        if (start > b || end < a) return 0;
        if (start >= a && end <= b) return tree[id];

        int mid = (start + end) / 2;
        return max(query(id * 2, start, mid, a, b), query(id * 2 + 1, mid + 1, end, a, b));
    }
};

int n, m, v[MAXN], nop;
int whatPath[MAXN], whatPos[MAXN], size[MAXN], parent[MAXN], level[MAXN];
vector<int> g[MAXN], paths[MAXN];
SegmentTree* trees[MAXN];


void HPD(int x, int p, int depth) {
    parent[x] = p;
    level[x] = depth;

    if (x != 1 && g[x].size() == 1) { // frunza
        size[x] = 1;
        nop++;
        whatPath[x] = nop;
        whatPos[x] = 0;
        paths[nop].push_back(x);
    } else { // nod intern
        int max_path, max_size = 0;
        for (int i = 0; i < g[x].size(); ++i) {
            int y = g[x][i];
            if (y == p) continue;
            HPD(y, x, depth + 1);
            size[x] += size[y];
            if (size[y] > max_size) {
                max_size = size[y];
                max_path = whatPath[y];
            }
        }

        size[x]++;
        whatPath[x] = max_path;
        whatPos[x] = paths[max_path].size();
        paths[max_path].push_back(x);
    }
}


int query(int x, int y, int MAX = 0) {
    if (whatPath[x] == whatPath[y]) {
        int path = whatPath[x];
        int a = min(whatPos[x], whatPos[y]);
        int b = max(whatPos[x], whatPos[y]);
        a++; b++;
        return max(MAX, trees[path] -> query(1, 1, trees[path]->n, a, b));
    }

    int xPathParent = paths[whatPath[x]][paths[whatPath[x]].size() - 1];
    int yPathParent = paths[whatPath[y]][paths[whatPath[y]].size() - 1];

    if (level[xPathParent] > level[yPathParent]) {
        MAX = max(MAX, trees[whatPath[x]] -> query(1, 1, trees[whatPath[x]]->n, whatPos[x] + 1, paths[whatPath[x]].size()));
        x = parent[xPathParent];
        return query(x, y, MAX);
    } else {
        MAX = max(MAX, trees[whatPath[y]] -> query(1, 1, trees[whatPath[y]]->n, whatPos[y] + 1, paths[whatPath[y]].size()));
        y = parent[yPathParent];
        return query(x, y, MAX);
    }
}


int main()
{

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

    HPD(1, 1, 1);

    calc();

    for (int i = 1; i <= nop; ++i) {
        trees[i] = new SegmentTree(paths[i].size());
        trees[i] -> build(1, 1, trees[i]->n, paths[i], v);
    }

    for (int i = 1, o, x, y; i <= m; ++i) {
        in >> o >> x >> y;
        if (o == 0) {
            int path = whatPath[x];
            trees[path] -> update(1, 1, trees[path]->n, whatPos[x] + 1, y);
        } else {
            out << query(x, y) << "\n";
        }
    }


    return 0;
}