#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()
{
    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);
    }
    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';
        }
    }