#include<fstream>
#include<vector>
#include<cmath>
#include<algorithm>

using namespace std;

typedef int var;

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

#define MAXN 100001
#define INF (1<<30)
#define MAXD 100001

struct Rmq {
    var rmq, sol;
    const bool operator<(const Rmq &t) const {
        return rmq < t.rmq;
    }
    Rmq(var a, var b) {
        sol = a;
        rmq = b;
    }
    Rmq(){sol = rmq = 0;}
};


vector<var> G[MAXN];
vector<vector<var> > PATH;
vector<var> PathP, IN, HEAVY, V, POZ, N, BEG;
//var LOG[3*MAXN];
var n, m, t;
var paths;
vector<var*>TREES;
//Rmq RMQ[18][3*MAXN];
vector<Rmq> EULER(1);
Rmq *LCAT;

void dfs(var node, var depth) {
    HEAVY[node] = 1;
    EULER.push_back(Rmq(node, depth));
    ++t;
    //RMQ[0][++t] = Rmq(node, depth);
    BEG[node] = t;
    var best = -1, in;
    for(auto vec : G[node]) {
        if(!BEG[vec]) {
            dfs(vec, depth+1);
            EULER.push_back(Rmq(node, depth));
            ++t;
            //RMQ[0][++t] = Rmq(node, depth);
            if(HEAVY[vec] > best) {
                best = HEAVY[vec];
                in = IN[vec];
            }
            PathP[IN[vec]] = node;
            HEAVY[node] += HEAVY[vec];
        }
    }
    if(best == -1) {
        IN[node] = ++paths;
        PATH.push_back(vector<var>());
        PathP.push_back(0);
        PATH[paths].push_back(node);
    } else {
        IN[node] = in;
        PATH[in].push_back(node);
    }
}

void build_lca_tree(var node, var b, var e) {
    if(b == e) {
        LCAT[node] = EULER[b];
        if(b == t)
            delete[] (LCAT+node+1);
    } else {
        var m = (b+e)/2;
        build_lca_tree(node*2, b, m);
        build_lca_tree(node*2+1, m+1, e);
        LCAT[node] = min(LCAT[node*2], LCAT[node*2+1]);
    }
}

Rmq queryL(var node, var b, var e, const var &l, const var &r) {
    if(b >= l && e <= r)
        return LCAT[node];
    if(l > e || r < b)
        return Rmq(INF, INF);
    var m = (b+e)/2;
    return min(queryL(node*2, b, m, l, r), queryL(node*2+1, m+1, e, l, r));
}

var lca(var n1, var n2) {
    n1 = BEG[n1];
    n2 = BEG[n2];
    if(n1 > n2) swap(n1, n2);
    Rmq res = queryL(1, 1, t, n1, n2);
    return res.sol;
}



void build_tree(const var &ind, var node, var b, var e) {
    var *TREE = TREES[ind];
    if(b == e) {
        TREE[node] = V[PATH[ind][b]];
        if(b == N[ind])
            delete[] (TREE+node+1);
    } else {
        var m = (b+e)/2;
        build_tree(ind, node*2, b, m);
        build_tree(ind, node*2+1, m+1, e);
        TREE[node] = max(TREE[node*2], TREE[node*2+1]);
    }
}

void update(const var &ind, var node, var b, var e, const var &poz, const var &val) {
    var *TREE = TREES[ind];
    if(b == e) {
        TREE[node] = val;
    } else {
        var m = (b+e)/2;
        if(poz <= m)
            update(ind, node*2, b, m, poz, val);
        else
            update(ind, node*2+1, m+1, e, poz, val);
        TREE[node] = max(TREE[node*2], TREE[node*2+1]);
    }
}

var query(const var &ind, var node, var b, var e, const var &l, const var &r) {
    var *TREE = TREES[ind];
    if(b >= l && e <= r)
        return TREE[node];
    if(l > e || r < b)
        return -INF;
    var m = (b+e)/2;
    return max(query(ind, node*2, b, m, l, r), query(ind, node*2+1, m+1, e, l, r));
}


var afla_max(var node, const var &parent) {
    var res = -INF;
    while(IN[node] != IN[parent]) {
        res = max(res, query(IN[node], 1, 1, N[IN[node]], 1, POZ[node]));
        node = PathP[IN[node]];
    }
    res = max(res, query(IN[node], 1, 1, N[IN[node]], POZ[parent], POZ[node]));

    return res;
}




int main() {
    var a, b;
    fin>>n>>m;

    PathP.resize(1, 0);
    IN.resize(n+1, 0);
    HEAVY.resize(n+1, 0);
    V.resize(n+1, 0);
    POZ.resize(n+1, 0);
    BEG.resize(n+1, 0);
    PATH.push_back(vector<var>());

    for(var i=1; i<=n; i++) {
        fin>>V[i];
    }
    var e = n-1;
    while(e--) {
        fin>>a>>b;
        G[a].push_back(b);
        G[b].push_back(a);
    }


    dfs(1, 0);
    HEAVY.clear();

    var size = 1.0*log(t)/log(2) + 2;
    LCAT = new Rmq[(1<<size)];
    //build_log();
    //build_rmq();
    build_lca_tree(1, 1, t);
    EULER.clear();

    N.resize(paths+1, 0);
    TREES.resize(paths+1, NULL);

    for(var i=1; i<=paths; i++) {
        PATH[i].push_back(0);
        N[i] = PATH[i].size() - 1;
        reverse(PATH[i].begin(), PATH[i].end());
        for(var j=1; j<=N[i]; j++) {
            POZ[PATH[i][j]] = j;
        }
    }

    for(var i=1; i<=paths; i++) {
        size = 1.0*log(N[i])/log(2) + 2;
        TREES[i] = new var[(1<<size)];
        build_tree(i, 1, 1, N[i]);
    }
    V.clear();

    var type, lc;


    while(m--) {
        fin>>type>>a>>b;
        if(type == 0) {
            update(IN[a], 1, 1, N[IN[a]], POZ[a], b);
        } else {
            var lc = lca(a, b);
            fout << max(afla_max(a, lc), afla_max(b, lc)) << '\n';
        }
    }

    return 0;
}