#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];
vector<int> g[nmax + 5];
int depth[nmax + 5], dim[nmax + 5], tata[nmax + 5];
int head[nmax + 5];
int pozHeavy[nmax + 5], cnt;

void dfs(int fiu, int nod)
{
    tata[fiu] = nod;
    dim[fiu] = 1;
    depth[fiu] = 1 + depth[nod];
    for(auto it : g[fiu])
    {
        if(it == nod)
        {
            continue;
        }
        dfs(it, fiu);
        dim[fiu] += dim[it];
    }
}

void dfsHeavy(int fiu, int nod)
{
    pozHeavy[fiu] = ++cnt;
    int heavySon = 0;
    for(auto it : g[fiu])
    {
        if(it == nod)
        {
            continue;
        }
        if(dim[it] > dim[heavySon])
        {
            heavySon = it;
        }
    }
    if(heavySon != 0)
    {
        head[heavySon] = head[fiu];
        dfsHeavy(heavySon, fiu);
    }
    for(auto it : g[fiu])
    {
        if(it == nod || it == heavySon)
        {
            continue;
        }
        dfsHeavy(it, fiu);
    }
}

int aint[4 * nmax + 5];

void update(int nod, int st, int dr, int poz, int val)
{
    if(st == dr)
    {
        aint[nod] = val;
        return ;
    }
    int mid = (st + dr) >> 1;
    if(poz <= mid)
    {
        update(2 * nod, st, mid, poz, val);
    }
    else
    {
        update(2 * nod + 1, mid + 1, dr, poz, 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 > dr || st > r || dr < l)
    {
        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)
{
    if(head[x] == head[y])
    {
        if(depth[x] > depth[y])
        {
            swap(x, y);
        }
        return query(1, 1, n, pozHeavy[x], pozHeavy[y]);
    }
    else
    {
        if(depth[head[x]] < depth[head[y]])
        {
            swap(x, y);
        }
        return max(query(1, 1, n, pozHeavy[head[x]], pozHeavy[x]),
                   queryHeavy(tata[head[x]], y));
    }
}

int main()
{
    fin >> 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);
    }
    dfs(1, 0);
    for(int i = 1; i <= n; i ++)
    {
        head[i] = i;
    }
    dfsHeavy(1, 0);
    for(int i = 1; i <= n; i ++)
    {
        update(1, 1, n, pozHeavy[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';
        }
    }
    return 0;
}