#include <bits/stdc++.h>
using namespace std;
ifstream fin("heavypath.in");
ofstream fout("heavypath.out");
const int nmax = 100000;
int n, m;
int val[nmax + 5], dim[nmax + 5], tata[nmax + 5], head[nmax + 5];
int nivel[nmax + 5], pozHeavy[nmax + 5], cnt;
int aint[4 * nmax + 5];
vector<int> g[nmax + 5];
void dfs(int fiu, int nod)
{
for(auto it : g[fiu])
{
if(it == nod)
{
continue;
}
tata[it] = fiu;
nivel[it] = 1 + nivel[fiu];
dfs(it, fiu);
dim[fiu] += dim[it];
}
}
void dfsHeavy(int fiu, int nod)
{
pozHeavy[fiu] = ++cnt;
int nodHeavy, maxDim = 0;
for(auto it : g[fiu])
{
if(it == nod)
{
continue;
}
if(dim[it] > maxDim)
{
maxDim = dim[it];
nodHeavy = it;
}
}
if(maxDim == 0)
{
return ;
}
head[nodHeavy] = head[fiu];
dfsHeavy(nodHeavy, fiu);
for(auto it : g[fiu])
{
if(it == nod || it == nodHeavy)
{
continue;
}
dfsHeavy(it, fiu);
}
}
void update(int nod, int st, int dr, int pozHeavy, int val)
{
if(st == dr)
{
aint[nod] = val;
return ;
}
int mid = (st + dr) >> 1;
if(pozHeavy <= mid)
{
update(2 * nod, st, mid, pozHeavy, val);
}
else
{
update(2 * nod + 1, mid + 1, dr, pozHeavy, val);
}
aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
}
int query(int nod, int st, int dr, int l, int r)
{
if(st > r || dr < l || st > dr)
{
return 0;
}
if(st >= l && dr <= r)
{
return aint[nod];
}
int mid = (st + dr) >> 1;
return max(query(2 * nod, st, mid, l, r),
query(2 * nod + 1, mid + 1, dr, l, r));
}
int queryHeavy(int x, int y)
{
int answer;
if(head[x] == head[y])
{
if(nivel[x] > nivel[y])
{
swap(x, y);
}
answer = query(1, 1, n, pozHeavy[x], pozHeavy[y]);
}
else
{
if(nivel[head[x]] < nivel[head[y]])
{
swap(x, y);
}
answer = query(1, 1, n, pozHeavy[head[x]], pozHeavy[x]);
x = tata[head[x]];
answer = max(answer, queryHeavy(x, y));
}
return answer;
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i ++)
{
fin >> val[i];
}
for(int i = 1; i < n; i ++)
{
int u, v;
fin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for(int i = 1; i <= n; i ++)
{
dim[i] = 1;
head[i] = i;
}
dfs(1, 0);
dfsHeavy(1, 0);
for(int i = 1; i <= n; i ++)
{
update(1, 1, n, i, val[i]);
}
while(m--)
{
int type, x, y;
fin >> type >> x >> y;
if(type == 0)
{
update(1, 1, n, pozHeavy[x], y);
}
else
{
fout << queryHeavy(x, y) << '\n';
}
}
}