#include <iostream>
#include <fstream>
#include <queue>
#include <set>
#include <algorithm>
#include <stack>
#include <vector>
#include <iomanip>
#include <cstdio>

using namespace std;

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

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];
int 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) / 2;
	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);
}

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);
	}
}

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 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() {
	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 (int i = 1; i <= m; ++i) {
		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;
}