#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
ifstream cin("heavypath.in");
ofstream cout("heavypath.out");
#define pb push_back
#define maxn 100050
inline int maxim(int a,int b){if(a>b)return a; return b;}
void swap(int&a,int&b){int aux=a;a=b,b=aux;}

int n,T,nL;
vector<int> g[maxn];
int v[maxn];
int viz[maxn],w[maxn],niv[maxn];
int lDim[maxn],l[maxn],difL[maxn],lNiv[maxn],lTata[maxn];
vector<int> Chains[maxn];
int arb[4*maxn],sol;

void df(int);
void build(int,int,int,int,int);
void update(int,int,int,int,int,int);
void querry(int,int,int,int,int,int);
void make_paths();

int main()
{
	int t,x,y;
	//citirea
	cin>>n>>T;
	for(int i=1;i<=n;i++)
		cin>>v[i];
	for(int i=1;i<n;i++){
		cin>>x>>y;
		g[x].pb(y);
		g[y].pb(x);
	}

	//rezolvare
	niv[1]=1;
	df(1);
	make_paths();
	for(;T--;)
	{
			cin>>t>>x>>y;
			if(t==0){
				update(1,1,lDim[l[x]],difL[l[x]],niv[x]-lNiv[l[x]],y);
			}else{
				sol=-1;
				while(1){
					if(l[x]==l[y]){
						if(niv[x]>niv[y])
							swap(x,y);
						querry(1,1,lDim[l[x]],niv[x]-lNiv[l[x]],niv[y]-lNiv[l[x]],difL[l[x]]);
						break;
					}
					if(lNiv[l[x]]<lNiv[l[y]])
						swap(x,y);
					querry(1,1,lDim[l[x]],1,niv[x]-lNiv[l[x]],difL[l[x]]);
					x=lTata[l[x]];
				}
				cout<<sol<<'\n';
			}
	}
	return 0;
}

void df(int nod){
	viz[nod]=1;
	int frunza=1,nivmax=-1;

	for(auto it=g[nod].begin();it!=g[nod].end();++it)
		if(!viz[*it]){
			frunza=0;//creare nivel
			niv[*it]=niv[nod]+1;
			df(*it);

			if(nivmax==-1)
				nivmax=*it;//obtinere niv max al lantului
			else
				if(w[nivmax]<w[*it])
					nivmax=*it;
		}
	if(frunza){
		l[nod]=++nL; //creare lant nou
		lDim[nL]=1;
		Chains[nL].pb(nod);
		return;
	}
	l[nod]=l[nivmax]; //adaugare nod in lantul coresp
	w[nod]=w[nivmax]+1;
	++lDim[l[nod]];
	Chains[l[nod]].pb(nod);

	for(auto it=g[nod].begin();it!=g[nod].end();++it){
		if((*it)==nivmax||niv[*it]<niv[nod])
			continue;
		lTata[l[*it]]=nod; //creare legatura intre
		lNiv[l[*it]]=niv[nod]; //lanturile secundare cu cel principal
	}
}

void build(int nod,int start,int end,int decalaj,int lant){
	if(start==end){
		arb[nod+decalaj]= v[ Chains[lant][start-1] ];
		return;
	}
	int mid=(start+end)/2;

	build(nod*2, start, mid, decalaj, lant);
	build(nod*2+1, mid+1, end, decalaj, lant);
	arb[nod+decalaj]=maxim(arb[2*nod + decalaj], arb[2*nod+1+decalaj] );
}

void make_paths()
{
	for(int i=1;i<=nL;++i){
		reverse(Chains[i].begin(),Chains[i].end());
		if(i>1)
			difL[i]=difL[i-1]+ 4*lDim[i-1];
		build(1,1,lDim[i],difL[i],i);
	}
}

void update(int nod, int start,int end,int decalaj, int poz, int val)
{
	if(start==end){
		arb[nod+decalaj]=val;
		return;
	}
	int mid=(start+end)/2;
	if(poz<=mid) update (nod*2,start,mid,decalaj,poz,val);
	else update(nod*2+1,mid+1,end,decalaj,poz,val);
	arb[nod+decalaj]=maxim(arb[nod*2+decalaj],arb[nod*2+1+decalaj]);
}

void querry(int nod,int start,int end,int qstart,int qend,int decalaj)
{
	if(qstart<=start&&end<=qend){
		sol=maxim(sol,arb[nod+decalaj]);
		return;
	}
	int mid=(start+end)/2;
	if(qstart<=mid)
		querry(2*nod,start,mid,qstart,qend,decalaj);
	if(mid<qend)
	querry(2*nod+1,mid+1,end,qstart,qend,decalaj);
}