#include <algorithm>
#include <iostream>
#include <fstream>
#include <climits>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#include <cassert>
#include <random>
#include <chrono>
// #pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
using ull = unsigned long long;
//using ll = long long;
//#define int __int128
//#define int ll
#define pii pair <int, int>
#define all(a) (a).begin(), (a).end()
#define fr first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define vt vector
#define FOR(a, b) for(int i = (a); i <= (b); i++)
#define FORr(a, b) for(int i = (a); i >= (b); i--)
#define sz(x) (int)(x).size()
#define YES cout << "YES\n"
#define NO cout << "NO\n"
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rangerng(int l, int r){
return uniform_int_distribution<>(l, r)(rng);
}
string filename = "heavypath";
ifstream fin(filename + ".in");
ofstream fout(filename + ".out");
////////////////////////////////////////////////////////////////////////////////////
const int NMAX = 1e5;
int n;
int v[NMAX + 1];
vt <int> adj[NMAX + 1];
int lvl[NMAX + 1];
int h[NMAX + 1];
int p[NMAX + 1];
int sub[NMAX + 1];
void explore(int node, int par){
p[node] = par;
lvl[node] = lvl[par] + 1;
sub[node] = 1;
for(int vec : adj[node]){
if(vec != par){
explore(vec, node);
sub[node] += sub[vec];
if(sub[vec] > sub[h[node]]){
h[node] = vec;
}
}
}
}
int Id = 0;
int id[NMAX + 1];
int head[NMAX + 1];
int Tm = 0;
int lin[NMAX + 1];
int pos[NMAX + 1];
void heavy_first(int node, int par){
lin[++Tm] = node;
pos[node] = Tm;
if(h[par] == node){
id[node] = id[par];
}else{
++Id;
id[node] = Id;
head[Id] = node;
}
if(h[node] != 0){
heavy_first(h[node], node);
}
for(int vec : adj[node]){
if(vec != par && vec != h[node]){
heavy_first(vec, node);
}
}
}
namespace AINT{
int aint[4 * NMAX + 1];
void build(int node, int l, int r){
if(l == r){
aint[node] = v[lin[l]];
return;
}
int mid = (l + r) / 2;
build(2 * node, l, mid);
build(2 * node + 1, mid + 1, r);
aint[node] = max(aint[2 * node], aint[2 * node + 1]);
}
void update(int node, int l, int r, int pos, int val){
if(l == r){
aint[node] = val;
return;
}
int mid = (l + r) / 2;
if(pos <= mid){
update(2 * node, l, mid, pos, val);
}else{
update(2 * node + 1, mid + 1, r, pos, val);
}
aint[node] = max(aint[2 * node], aint[2 * node + 1]);
}
int query(int node, int l, int r, int ql, int qr){
if(ql <= l && r <= qr){
return aint[node];
}
int ans = 0, mid = (l + r) / 2;
if(ql <= mid){
ans = max(ans, query(2 * node, l, mid, ql, qr));
}
if(mid + 1 <= qr){
ans = max(ans, query(2 * node + 1, mid + 1, r, ql, qr));
}
return ans;
}
}
int query(int x, int y){
int ans = 0;
while(id[x] != id[y]){
//cout << x << ' ' << y << endl;
if(lvl[x] > lvl[y]){
ans = max(ans, AINT::query(1, 1, n, pos[head[id[x]]], pos[x]));
x = p[head[id[x]]];
}else{
ans = max(ans, AINT::query(1, 1, n, pos[head[id[y]]], pos[y]));
y = p[head[id[y]]];
}
}
//cout << "!!1\n";
if(x != 0){
ans = max(ans, AINT::query(1, 1, n, min(pos[x], pos[y]), max(pos[x], pos[y])));
}
//cout << "!!2\n";
return ans;
}
void solve(){
int q;
fin >> n >> q;
for(int i = 1; i <= n; i++){
fin >> v[i];
}
for(int i = 1; i <= n - 1; i++){
int a, b;
fin >> a >> b;
adj[a].pb(b);
adj[b].pb(a);
}
explore(1, 0);
heavy_first(1, 0);
AINT::build(1, 1, n);
while(q--){
int type;
fin >> type;
if(type == 0){
int node, x;
fin >> node >> x;
AINT::update(1, 1, n, pos[node], x);
}else{
int x, y;
fin >> x >> y;
fout << query(x, y) << '\n';
}
}
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
//fin >> T;
T = 1;
while(T--){
solve();
}
return 0;
}
/*
*/