#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;

class HLDecomposition {
	Graph g;
	vector<int> vid, head, heavy, par, depth, inv;
	int dfs(int curr, int prev) {
		par[curr] = prev;
		int sub = 1, max_sub = 0;
		for (auto next : g[curr]) if (next != prev) {
			depth[next] = depth[curr] + 1;
			int sub_next = dfs(next, curr);
			sub += sub_next;
			if (max_sub < sub_next) max_sub = sub_next, heavy[curr] = next;
		}
		return sub;
	}
	void bfs() {
		int k = 0;
		queue<int> q; q.push(0);
		while (!q.empty()) {
			int h = q.front(); q.pop();
			for (int i = h; i != -1; i = heavy[i]) {
				vid[i] = k++;
				inv[vid[i]] = i;
				head[i] = h;
				for (auto j : g[i]) if (j != par[i] && j != heavy[i]) q.push(j);
			}
		}
	}
public:
	HLDecomposition(int n)
		: g(n), vid(n, -1), head(n), heavy(n, -1), par(n), depth(n), inv(n) {}
	void add(int u, int v) {
		g[u].push_back(v);
		g[v].push_back(u);
	}
	void build() {
		dfs(0, -1);
		bfs();
	}
	void for_each(int u, int v, function<void(int, int)> f) {
		if (vid[u] > vid[v]) swap(u, v);
		f(max(vid[head[v]], vid[u]), vid[v]);
		if (head[u] != head[v]) for_each(u, par[head[v]], f);
	}
	void for_each_directed(int u, int v, function<void(int, int, int)> f) {
		if (vid[u] > vid[v]) {
			f(max(vid[head[u]], vid[v]), vid[u], 1);
			if (head[u] != head[v]) for_each_directed(par[head[u]], v, f);
		}
		else {
			f(max(vid[head[v]], vid[u]), vid[v], 0);
			if (head[u] != head[v]) for_each_directed(u, par[head[v]], f);
		}
	}
};


struct node {
	bool flag, id;
	ll l, r, all, sum, cnt, lazy;
	node(ll val) : flag(false), id(false), l(val), r(val), all(val), sum(val), cnt(1), lazy(0) {}
	node(ll l, ll r, ll all, ll sum, ll cnt) : flag(false), id(false), l(l), r(r), all(all), sum(sum), cnt(cnt), lazy(0) {}
	node() : flag(false), id(true), cnt(0), lazy(0) {}
};

node merge(const node& l, const node& r) {
	if (l.id) return r;
	if (r.id) return l;
	ll resl = max(l.l, l.sum + r.l);
	ll resr = max(l.r + r.sum, r.r);
	ll ressum = l.sum + r.sum;
	ll rescen = max(l.all, max(r.all, max(l.r + r.l, max(l.r, r.l))));
	return node(resl, resr, max(rescen, max(resl, resr)), ressum, l.cnt + r.cnt);
}

node real(const node& n) {
	if (!(n.flag) || n.id) return n;
	ll sum = n.lazy * n.cnt;
	return n.lazy >= 0 ? node(sum, sum, sum, sum, n.cnt) : node(n.lazy, n.lazy, n.lazy, sum, n.cnt);
}

class LazySegmentTree {
	const int n;
	vector<node> data;
	int size(int n) {
		int res = 1;
		while (res < n) res <<= 1;
		return res;
	}
	void suc(int l, int r, int node, int lb, int ub, ll val) {
		if (ub <= l || r <= lb) return;
		if (l <= lb && ub <= r) {
			data[node].flag = true;
			data[node].id = false;
			data[node].lazy = val;
			return;
		}
		int left = node * 2, right = node * 2 + 1;
		if (data[node].flag) {
			data[left].flag = data[right].flag = true;
			data[left].id = data[right].id = false;
			data[left].lazy = data[right].lazy = data[node].lazy;
			data[node] = real(data[node]);
			data[node].flag = false;
		}
		suc(l, r, left, lb, (lb + ub) / 2, val);
		suc(l, r, right, (lb + ub) / 2, ub, val);
		data[node] = merge(real(data[left]), real(data[right]));
	}
	node sub(int l, int r, int node, int lb, int ub) {
		if (ub <= l || r <= lb) return ::node();
		if (l <= lb && ub <= r) {
			return real(data[node]);
		}
		int left = node * 2, right = node * 2 + 1;
		if (data[node].flag) {
			data[left].flag = data[right].flag = true;
			data[left].id = data[right].id = false;
			data[left].lazy = data[right].lazy = data[node].lazy;
			data[node] = real(data[node]);
			data[node].flag = false;
		}
		return merge(sub(l, r, left, lb, (lb + ub) / 2), sub(l, r, right, (lb + ub) / 2, ub));
	}
public:
	LazySegmentTree(int n_) :
		n(size(n_)), data(n * 2, node()) {}
	void Init() {
		for (int i = n - 1; i > 0; i--) {
			data[i] = merge(data[i * 2], data[i * 2 + 1]);
		}
	}
	void update(int p, ll val) {
		data[n + p] = node(val);
	}
	void update(int l, int r, ll val) {
		suc(l, r + 1, 1, 0, n, val);
	}
	node find(int l, int r) {
		return sub(l, r + 1, 1, 0, n);
	}
};

int main()
{
	cin.sync_with_stdio(false);
	cin.tie(0);
	ll n, q, t, a, b, c;
	cin >> n >> q;
	vector<ll> w(n);
	for (int i = 0; i < n; i++) {
		cin >> w[i];
	}
	HLDecomposition hl(n);
	for (int i = 0, u, v; i < n - 1; i++) {
		cin >> u >> v; u--; v--;
		hl.add(u, v);
	}
	hl.build();
	LazySegmentTree lst(n);
	for (int i = 0; i < n; i++) {
		hl.for_each(i, i, [&](int l, int r) {
			lst.update(l, w[i]);
		});
	}
	lst.Init();
	while (q--) {
		cin >> t >> a >> b >> c; a--; b--;
		if (t == 1) {
			hl.for_each(a, b, [&](int l, int r) {
				lst.update(l, r, c);
			});
		}
		else {
			node left, right;
			hl.for_each_directed(a, b, [&](int l, int r, int b) {
				if (b) {
					auto tmp = lst.find(l, r); swap(tmp.l, tmp.r);
					left = merge(left, tmp);
				}
				else {
					right = merge(lst.find(l, r), right);
				}
			});
			node res = merge(left, right);
			printf("%lld\n", res.all);
		}
	}
	return 0;
}

Measured memory_bytes: 56728