#include <bits/stdc++.h>

using namespace std;

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

void usain_bolt()
{
    ios::sync_with_stdio(false);
    fin.tie(0);
}

const int N = 1e5 + 5;

vector < int > a[N], lant[N];
int val[N], Size[N], heavy[N], height[N], dad[N], place[N], pos[N], tree[N * 4], delay[N], total;

void update(int left, int right, int node, int pos, int val, int dist)
{
    if(left > right) {
        return ;
    }
    if(left == right) {
        tree[node + dist] = val;
        return ;
    }
    int mid = (left + right) >> 1;
    if(mid >= pos) {
        update(left, mid, node * 2, pos, val, dist);
    }
    else {
        update(mid + 1, right, node * 2 + 1, pos, val, dist);
    }
    tree[node + dist] = max(tree[node * 2 + dist], tree[node * 2 + 1 + dist]);
}

int query(int left, int right, int node, int x, int y, int dist)
{
    if(left > right) {
        return 0;
    }
    if(left >= x && right <= y) {
        return tree[node + dist];
    }
    int mid = (left + right) >> 1;
    int ans1 = 0, ans2 = 0;
    if(mid >= x) {
        ans1 = query(left, mid, node * 2, x, y, dist);
    }
    if(mid + 1 <= y) {
        ans2 = query(mid + 1, right, node * 2 + 1, x, y, dist);
    }
    return max(ans1, ans2);
}

void build()
{
    int sum = 0;
    for(int i = 1; i <= total; ++i) {
        delay[i] = sum;
        for(auto v : lant[i]) {
            update(1, (int) lant[i].size(), 1, pos[v], val[v], delay[i]);
        }
        sum += (int) lant[i].size() * 4;
    }
}

void dfs(int k)
{
    Size[k] = 1;
    for(auto v : a[k]) {
        if(v == dad[k]) {
            continue;
        }
        height[v] = height[k] + 1;
        dad[v] = k;
        dfs(v);
        Size[k] += Size[v];
        if(Size[v] > Size[heavy[k]] || heavy[k] == 0) {
                heavy[k] = v;
        }
    }
}

void divide(int k, int act_lant)
{
    lant[act_lant].push_back(k);
    place[k] = act_lant;
    pos[k] = (int) lant[act_lant].size();
    if(heavy[k] != 0) {
        divide(heavy[k], act_lant);
    }
    for(auto v : a[k]) {
        if(v == dad[k] || v == heavy[k]) {
            continue;
        }
        divide(v, ++total);
    }
}

int solve(int x, int y)
{
    int ans = 0;
    while(place[x] != place[y]) {
        if(height[lant[place[x]][0]] < height[lant[place[y]][0]]) {
            swap(x, y);
        }
        ans = max(ans, query(1, (int) lant[place[x]].size(), 1, 1, pos[x], delay[place[x]]));
        x = dad[lant[place[x]][0]];
    }
    if(pos[x] > pos[y]) {
        swap(x, y);
    }
    ans = max(ans, query(1, (int) lant[place[x]].size(), 1, pos[x], pos[y], delay[place[x]]));
    return ans;
}

int main()
{
    usain_bolt();

    int n, q;

    fin >> n >> q;
    for(int i = 1; i <= n; ++i) {
        fin >> val[i];
    }
    for(int i = 1; i < n; ++i) {
        int x, y;

        fin >> x >> y;
        a[x].push_back(y);
        a[y].push_back(x);
    }
    dfs(1);
    divide(1, ++total);
    build();
    for(; q; --q) {
        int type, x, y;

        fin >> type >> x >> y;
        switch(type) {
            case 0:
                update(1, (int) lant[place[x]].size(), 1, pos[x], y, delay[place[x]]);
                break;
            case 1:
                fout << solve(x, y) << "\n";
                break;
        }
    }
    return 0;
}