#include <stdio.h>
#include <vector>
#include <utility>
#include <algorithm>

using namespace std;
vector <int> path[100001],v[100001],a[100001];
int whatpoz[100001],whatpath[100001],val[100001],tata[100001],ter[100001],x,y,i,n,m,tare,max1,niv[100001],sub[100001],nr,tip;
FILE *f,*g;
void df (int x)
{
    niv[x]=niv[tata[x]]+1;
    int j;
    int fiu=0;
    for (j=0;j<v[x].size ();j++)
    {
        if (tata[v[x][j]]==0 && v[x][j]!=1)
        {
            tata[v[x][j]]=x;
            df (v[x][j]);
            sub[x]+=sub[v[x][j]];
            if (sub[v[x][j]]>sub[fiu]) fiu=v[x][j];
        }
    }
    if (fiu==0)
       {
           path[++nr].push_back (x);
           whatpath[x]=nr;
           sub[x]=1;
       }
      else
      {
          path[whatpath[fiu]].push_back (x);
          whatpath[x]=whatpath[fiu];
      }
}
void fa (int nod,int st, int dr,int pat)
{
    if (st==dr)
    {
        a[pat][nod]=val[path[pat][st]];
    }
    else
    {
    int mij=(st+dr)/2;
    fa (nod*2,st,mij,pat);
    fa (nod*2+1,mij+1,dr,pat);
    a[pat][nod]=max (a[pat][2*nod],a[pat][2*nod+1]);
    tare=a[pat][nod];
    }
}
void baga ()
{
    int j;
    for (j=1;j<=nr;j++)
    {
        reverse (path[j].begin (),path[j].end ());
        ter[j]=path[j][0];
        for (int k=0;k<path[j].size ();k++)
        {
            tare=path[j][k];
            whatpoz[path[j][k]]=k;
        }
        a[j].resize (4*path[j].size ());
        fa (1,0,path[j].size ()-1,j);
    }

}
void update (int nod,int st,int dr,int pat)
{
    if (st==dr)
    {
        a[pat][nod]=x;
    }
    else
        {
            int mij=(st+dr)/2;
            if (mij>=whatpoz [x]) update (nod*2,st,mij,pat);
              else update (nod*2+1,mij+1,dr,pat);
              a[pat][nod]=max (a[pat][nod*2],a[pat][nod*2+1]);
        }

}
void querry (int nod,int st,int dr,int pat,int x,int y)
{
    if (st>=x && y>=dr)
    {
        max1=max (max1,a[pat][nod]);
    }
    else
    {
       int mij=(st+dr)/2;


        if (x<=mij) querry (nod*2,st,mij,pat,x,y);
        if (mij<y) querry (nod*2+1,mij+1,dr,pat,x,y);
    }
}
void cauta (int x,int y)
{
    if (whatpath[x]==whatpath[y])
    {
        querry (1,0,path[whatpath[y]].size()-1,whatpath[y],min(whatpoz[x],whatpoz[y]),max (whatpoz[x],whatpoz[y]));
    }
    else
    {
        int t1,t2;
        t1=ter[whatpath[x]];
        t2=ter[whatpath[y]];
        if (niv[t2]<niv[t1])
        {
            swap (t1,t2);
            swap (x,y);
        }
        querry (1,0,path[whatpath[y]].size()-1,whatpath[y],0,whatpoz[y]);
        cauta (tata[t2],x);
    }
}
int main()
{f=fopen ("heavypath.in","r");
 g=fopen ("heavypath.out","w");
 fscanf (f,"%d%d",&n,&m);
 for (i=1;i<=n;i++) fscanf (f,"%d",&val[i]);
 for (i=1;i<n;i++)
 {
     fscanf (f,"%d%d",&x,&y);
     v[x].push_back (y);
     v[y].push_back (x);
 }

df (1);
baga ();
for (i=1;i<=m;i++)
{
    fscanf (f,"%d%d%d",&tip,&x,&y);
    if (tip==0) update (1,0,path[whatpath[x]].size()-1,whatpath[x]);
     else
     {
         max1=-1;
         cauta (x,y);
         fprintf (g,"%d\n",max1);
     }

}

    return 0;
}