#include <bits/stdc++.h>

using namespace std;

class SegmentTree
{
private:
    vector<int> tree;
    int N;

    void build(int node, int l, int r, const vector<int> &values)
    {
        if (l == r)
            tree[node] = values[l];
        else
        {
            int m = (l + r) / 2;

            build(2 * node, l, m, values);
            build(2 * node + 1, m + 1, r, values);

            tree[node] = max(tree[2 * node], tree[2 * node + 1]);
        }
    }

    void update(int node, int l, int r, int pos, int key)
    {
        if (l == r)
            tree[node] = key;
        else
        {
            int m = (l + r) / 2;

            if (pos <= m)
                update(2 * node, l, m, pos, key);
            else
                update(2 * node + 1, m + 1, r, pos, key);

            tree[node] = max(tree[2 * node], tree[2 * node + 1]);
        }
    }

    int query(int node, int l, int r, int st_q, int dr_q)
    {
        if (st_q <= l && r <= dr_q)
            return tree[node];
        else
        {
            int m = (l + r) / 2;
            int answer = numeric_limits<int>::min();

            if (st_q <= m)
                answer = max(answer, query(2 * node, l, m, st_q, dr_q));

            if (m < dr_q)
                answer = max(answer, query(2 * node + 1, m + 1, r, st_q, dr_q));

            return answer;
        }
    }

public:

    SegmentTree(const vector<int>& values){
        N = values.size();
        tree.resize(4 * N);
        build(1, 0, N - 1, values);
    }

    void update(int pos, int key)
    {
        update(1, 0, N - 1, pos, key);
    }

    int query(int x, int y)
    {
        return query(1, 0, N - 1, x, y);
    }
};

constexpr int MAX_N = 100000 + 1;

vector<int> G[MAX_N];
int keys[MAX_N];

int depth[MAX_N], father[MAX_N], subTree[MAX_N];
int path[MAX_N], lengthPath[MAX_N], posInPath[MAX_N], startNode[MAX_N];

vector<SegmentTree> ST;

int N, Q;
int numberOfPaths;

void dfs(int node)
{
    int hson = 0;
    subTree[node] = 1;

    for (int v : G[node])
    {
        if (father[v] == 0)
        {
            father[v] = node;
            depth[v] = depth[node] + 1;
            dfs(v);

            subTree[node] += subTree[v];

            if (subTree[v] > subTree[hson])
                hson = v;
        }
    }

    if (hson == 0)
        path[node] = numberOfPaths++;
    else
        path[node] = path[hson];

    posInPath[node] = lengthPath[ path[node] ]++;
}

void buildHPD()
{
    father[1] = 1;
    depth[1] = 0;
    dfs(1);

    for (int i = 1; i <= N; ++i)
    {
        posInPath[i] = lengthPath[ path[i] ] - posInPath[i] - 1;

        if (posInPath[i] == 0)
            startNode[ path[i] ] = i;
    }
}

void buildSegmentTrees()
{
    vector<vector<int>> pathValues(numberOfPaths);

    for (int i = 0; i < numberOfPaths; ++i)
        pathValues[i].resize(lengthPath[i]);

    for (int i = 1; i <= N; ++i)
        pathValues[ path[i] ][ posInPath[i] ] = keys[i];

    for (int i = 0; i < numberOfPaths; ++i)
        ST.push_back(SegmentTree(pathValues[i]));
}

void updateNode(int node, int newKey)
{
    ST[ path[node] ].update(posInPath[node], newKey);
}

int query(int x, int y)
{
    if (depth[ startNode[ path[x] ] ] < depth[ startNode[ path[y] ] ])
        swap(x, y);

    if (path[x] == path[y])
        return ST[ path[x] ].query(min(posInPath[x], posInPath[y]), max(posInPath[x], posInPath[y]));
    else
        return max(ST[path[x]].query(0, posInPath[x]), query(father[ startNode[ path[x] ] ], y));
}

int main()
{
    ifstream in("heavypath.in");
    ofstream out("heavypath.out");

    in >> N >> Q;

    for (int i = 1; i <= N; ++i)
        in >> keys[i];

    for (int i = 0; i < N - 1; ++i)
    {
        int a, b;
        in >> a >> b;

        G[a].push_back(b);
        G[b].push_back(a);
    }

    buildHPD();
    buildSegmentTrees();

    while (Q--)
    {
        int t, x, k;
        in >> t >> x >> k;

        if (t == 0)
            updateNode(x, k);
        else
            out << query(x, k) << "\n";
    }

    return 0;
}