#include <bits/stdc++.h>

using namespace std;

ifstream fin("heavypath.in");
ofstream fout("heavypath.out");

void usain_bolt()
{
	ios::sync_with_stdio(false);
	fin.tie(0);
}

const int N = 1e5 + 5;

vector < int > a[N];
vector < int > lant[N];

int val[N], sz[N], h[N], heavy[N], dad[N], pos[N], place[N], total, tree[N * 4], delay[N];

void update(int left, int right, int node, int pos, int val, int dist)
{
	if (left == right) {
		tree[node + dist] = val;
		return;
	}
	int mid = (left + right) >> 1;
	if (pos <= mid) {
		update(left, mid, node * 2, pos, val, dist);
	}
	else {
		update(mid + 1, right, node * 2 + 1, pos, val, dist);
	}
	tree[node + dist] = max(tree[node * 2 + dist], tree[node * 2 + 1 + dist]);
}

int query(int left, int right, int node, int x, int y, int dist)
{
	if (left > right) return 0;
	if (left >= x && right <= y) {
		return tree[node + dist];
	}
	int mid = (left + right) >> 1;
	int ans1 = 0, ans2 = 0;
	if (mid >= x) {
		ans1 = query(left, mid, node * 2, x, y, dist);
	}
	if (mid + 1 <= y) {
		ans2 = query(mid + 1, right, node * 2 + 1, x, y, dist);
	}
	return max(ans1, ans2);
}

void build()
{
	int sum = 0;
	for (int i = 1; i <= total; ++i) {
		delay[i] = sum;
		for (auto v : lant[i]) {
			update(1, (int)lant[i].size(), 1, pos[v], val[v], delay[i]);
		}
		sum += (int)lant[i].size() * 4;
	}
}

int dfs(int k, int daddy)
{
	sz[k] = 1;
	for (auto v : a[k]) {
		if (v == dad[k]) continue;
		dad[v] = k;
		h[v] = h[k] + 1;
		dfs(v, k);
		sz[k] += sz[v];
		if (sz[v] > sz[heavy[k]] || heavy[k] == 0) {
			heavy[k] = v;
		}
	}
}

int divide(int k, int act_lant)
{
	lant[act_lant].push_back(k);
	place[k] = act_lant;
	pos[k] = (int)lant[act_lant].size();
	if (heavy[k] != 0) {
		divide(heavy[k], act_lant);
	}
	for (auto v : a[k]) {
		if (v == dad[k] || v == heavy[k]) continue;
		divide(v, ++total);
	}
}

int solve(int x, int y)
{
	int ans = 0;
	while (place[x] != place[y]) {
		if (h[lant[place[x]][0]] < h[lant[place[y]][0]]) {
			swap(x, y);
		}
		ans = max(ans, query(1, (int)lant[place[x]].size(), 1, 1, pos[x], delay[place[x]]));
		x = dad[lant[place[x]][0]];
	}
	if (pos[x] > pos[y]) {
		swap(x, y);
	}
	ans = max(ans, query(1, (int)lant[place[x]].size(), 1, pos[x], pos[y], delay[place[x]]));
	return ans;
}

int main()
{
	usain_bolt();

	int n, m;

	fin >> n >> m;
	for (int i = 1; i <= n; ++i) {
		fin >> val[i];
	}
	for (int i = 1; i < n; ++i) {
		int x, y;

		fin >> x >> y;
		a[x].push_back(y);
		a[y].push_back(x);
	}
	dfs(1, 0);
	divide(1, ++total);
	build();
	for (; m; --m) {
		int type, x, y;

		fin >> type >> x >> y;
		if (type == 0) {
			update(1, (int)lant[place[x]].size(), 1, pos[x], y, delay[place[x]]);
		}
		else {
			fout << solve(x, y) << "\n";
		}
	}
	return 0;
}