#include <bits/stdc++.h>

using namespace std;

class SegmentTree
{
public:

    vector<int> tree;
    int N;

    SegmentTree(const vector<int> &v) ///0-based
    {
        N = v.size();
        tree.resize(4 * N, 0);

        build(1, 0, N - 1, v);
    }

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

            build(2 * node, st, m, v);
            build(2 * node + 1, m + 1, dr, v);

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

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

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

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

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

            if (st_q <= m)
                ans = max(ans, query(2 * node, st, m, st_q, dr_q));

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

            return ans;
        }
    }

    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);
    }
};

const int MAX_N = 100000 + 1;

vector<int> G[MAX_N];
vector<SegmentTree> ST;

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

int N, Q, numberOfPaths;

void dfs(int node)
{
    int heavy = 0;
    size[node] = 1;

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

            dfs(v);

            size[node] += size[v];

            if (size[v] > size[heavy])
                heavy = v;
        }
    }

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

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

void buildHeavy()
{
    depth[1] = 1;
    father[1] = 1;
    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] = vector<int>(lengthPath[i], 0);

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

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

void update(int node, int key)
{
    valueNode[node] = key;
    ST[ path[node] ].update(posInPath[node], key);
}

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 >> valueNode[i];

    for (int i = 2; i <= N; ++i)
    {
        int x, y;
        in >> x >> y;

        G[x].emplace_back(y);
        G[y].emplace_back(x);
    }

    buildHeavy();
    buildSegmentTrees();

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

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

    return 0;
}