#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>

#define debug(x) #x << " = " << x << '\n'

using ll = long long;
const int INF = +1e9;
const int NMAX = 1e5;

struct segtree {
  int n;
  std::vector<int> aint;

  void init(int _n) {
    n = _n;
    aint.resize(4 * n + 1, 0);
  }

  void update(int node, int tl, int tr, int p, int v) {
    if (tl == tr) {
      aint[node] = v;
    } else {
      int mid = (tl + tr) / 2;
      if (p <= mid) {
        update(2 * node, tl, mid, p, v);
      } else {
        update(2 * node + 1, mid + 1, tr, p, v);
      }
      aint[node] = std::max(aint[2 * node], aint[2 * node + 1]);
    }
  }

  int query(int node, int tl, int tr, int l, int r) {
    if (l <= tl && tr <= r) {
      return aint[node];
    }
    int mid = (tl + tr) / 2;
    int ret = 0;
    if (l <= mid) {
      ret = std::max(ret, query(2 * node, tl, mid, l, r));
    }
    if (mid < r) {
      ret = std::max(ret, query(2 * node + 1, mid + 1, tr, l, r));
    }
    return ret;
  }

  void update(int pos, int val) {
    update(1, 1, n, pos, val);
  }
  int query(int l, int r) {
    return query(1, 1, n, l, r);
  }
};

std::vector<int> g[NMAX + 1];
int a[NMAX + 1];
int sz[NMAX + 1];
int head[NMAX + 1];
int depth[NMAX + 1];
int heavySon[NMAX + 1];
int parent[NMAX + 1];
int tin[NMAX + 1];
int tout[NMAX + 1];
int timer;

void dfs(int u, int p = 0) {
  if (p) {
    int ptr = 0;
    while (g[u][ptr] != p) {
      ptr++;
    }
    g[u].erase(g[u].begin() + ptr);
  }

  parent[u] = p;
  depth[u] = 1 + depth[p];
  sz[u] = 1;
  for (const auto &v : g[u]) {
    dfs(v, u);
    sz[u] += sz[v];
    if (sz[v] > sz[heavySon[u]]) {
      heavySon[u] = v;
    }
  }
}

void dfsheavy(int u, int h) {
  tin[u] = ++timer;
  head[u] = h;
  if (heavySon[u]) {
    dfsheavy(heavySon[u], h);
  }
  for (const auto &v : g[u]) {
    if (v != heavySon[u]) {
      dfsheavy(v, v);
    }
  }
  tout[u] = timer;
}
segtree aint;

void updatePos(int u, int value) {
  aint.update(tin[u], value);
}

int queryPath(int u, int v) {
  int ret = 0;
  while (head[u] != head[v]) {
    if (depth[head[u]] > depth[head[v]]) {
      ret = std::max(ret, aint.query(tin[head[u]], tin[u]));
      u = parent[head[u]];
    } else {
      ret = std::max(ret, aint.query(tin[head[v]], tin[v]));
      v = parent[head[v]];
    }
  }
  if (tin[u] > tin[v]) {
    std::swap(u, v);
  }
  ret = std::max(ret, aint.query(tin[u], tin[v]));
  return ret;
}

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);
  std::cout.tie(0);
  #ifndef LOCAL
freopen("heavypath.in", "r", stdin);
freopen("heavypath.out", "w", stdout);
  #endif // LOCAL

  int n, q;
  std::cin >> n >> q;

  for (int i = 1; i <= n; i++) {
    std::cin >> a[i];
  }

  for (int i = 1; i < n; i++) {
    int u, v;
    std::cin >> u >> v;
    g[u].push_back(v);
    g[v].push_back(u);
  }

  dfs(1);
  dfsheavy(1, 1);

  aint.init(n);

  for (int i = 1; i <= n; i++) {
    updatePos(i, a[i]);
  }

  while (q--) {
    int type, x, y;
    std::cin >> type >> x >> y;
    if (type == 0) {
      updatePos(x, y);
    } else {
      std::cout << queryPath(x, y) << '\n';
    }
  }

  return 0;
}