#include <iostream>
#include <vector>
#include <algorithm>
#include <limits>
#include <numeric>
#include <cstring>
#include <string>
#include <queue>
#include <set>
#include <cmath>
#include <fstream>
#include <cstdlib>
#include <map>
#include <stack>
#define pb push_back
#define mp make_pair
#define INF numeric_limits<int>::max()
#define lsb(x) (-x)&x
#define int64 long long
using namespace std;
ifstream in("heavypath.in");
ofstream out("heavypath.out");
vector< vector<int> > adj,path;
vector<int> pathSize,LCAtree,v,eul,lvl,pos,firstNode,comp,parent,pathPos;
priority_queue< pair<int,int> > leafs;
int n,k,np;
void euler(int x,int px)
{
    lvl[x]=lvl[px]+1;
    eul[++k]=x;
    pos[x]=k;
    parent[x]=px;
    if(adj[x].size()==1 && x!=1)
        leafs.push(mp(lvl[x],x));
    else for(auto it: adj[x])
    if(it!=px)
    {
        euler(it,x);
        eul[++k]=x;
    }
}
void LCAupd(int x,int left,int right,int position)
{
    if(left==right)
        LCAtree[x]=eul[position];
    else{
        int mid=(left+right)/2;
        if(position<=mid)
            LCAupd(2*x,left,mid,position);
        else
            LCAupd(2*x+1,mid+1,right,position);
        LCAtree[x]=(lvl[ LCAtree[2*x] ] < lvl[ LCAtree[2*x+1] ] ? LCAtree[2*x] : LCAtree[2*x+1]);
    }
}
int lca;
void LCAquery(int x,int left,int right,int a,int b)
{
    if(a<=left && b>=right)
        lca=(lvl[ lca ] < lvl[ LCAtree[x] ] ? lca : LCAtree[x]);
    else{
        int mid=(left+right)/2;
        if(a<=mid)
            LCAquery(2*x,left,mid,a,b);
        if(b>mid)
            LCAquery(2*x+1,mid+1,right,a,b);
    }
}
void pathUpd(int x,int left,int right,int position,int val,vector<int> &tree)
{
    if(left==right)
        tree[x]=val;
    else{
        int mid=(left+right)/2;
        if(position<=mid)
            pathUpd(2*x,left,mid,position,val,tree);
        else
            pathUpd(2*x+1,mid+1,right,position,val,tree);
        tree[x]=max(tree[2*x],tree[2*x+1]);
    }
}
int sol;
void pathQuery(int x,int left,int right,int a,int b,vector<int> tree)
{
    if(a<=left && b>=right)
        sol=max(sol,tree[x]);
    else{
        int mid=(left+right)/2;
        if(a<=mid)
            pathQuery(2*x,left,mid,a,b,tree);
        if(b>mid)
            pathQuery(2*x+1,mid+1,right,a,b,tree);
    }
}
void update(int x,int val)
{
    pathUpd(1,1,pathSize[ comp[x] ],pathPos[x],val,path[ comp[x] ]);
}
void getMax(int x,int lca)
{
    int node=x;
    while(comp[node]!=comp[lca])
    {
        pathQuery(1,1,pathSize[ comp[node] ],1,pathPos[node],path[ comp[node] ]);
        node=parent[ firstNode[ comp[node] ] ];
    }
    pathQuery(1,1,pathSize[ comp[node] ],pathPos[lca],pathPos[node],path[ comp[node] ]);
}
int query(int x,int y)
{
    lca=0;
    if(pos[x]>pos[y])
        swap(x,y);
    LCAquery(1,1,k,pos[x],pos[y]);
    sol=-INF;
    getMax(x,lca);
    getMax(y,lca);
    return sol;
}
int main()
{
    int q;
    in>>n>>q;
    adj=path=vector< vector<int> > (n+1);
    pathSize=lvl=pos=parent=firstNode=comp=pathPos=v=vector<int> (n+1);
    eul=vector<int> (2*n+3);
    for(int i=1;i<=n;i++)
        in>>v[i];
    for(int i=2;i<=n;i++)
    {
        int x,y;
        in>>x>>y;
        adj[x].pb(y);
        adj[y].pb(x);
    }
    euler(1,0);
    comp[0]=-1;
    lvl[0]=INF;
    LCAtree=vector<int> (4*k+1);
    for(int i=1;i<=k;i++)
        LCAupd(1,1,k,i);
    while(!leafs.empty())
    {
        np++;
        int x;
        for(x=leafs.top().second;comp[x]==0;x=parent[x])
            pathSize[np]++;
        path[np]=vector<int> (4*pathSize[np]+1);
        for(int i=pathSize[np],x=leafs.top().second;comp[x]==0;x=parent[x],i--)
        {
            pathUpd(1,1,pathSize[np],i,v[x],path[np]);
            comp[x]=np;
            firstNode[np]=x;
            pathPos[x]=i;
        }
        leafs.pop();
    }
    for(;q;q--)
    {
        int x,y,t;
        in>>t>>x>>y;
        if(t==0)
            update(x,y);
        else
            out<<query(x,y)<<'\n';
    }
    return 0;
}