#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 1e6 + 5;
const int INF = 2e9 + 10;

int n, q;
int fa[N], sz[N], d[N], son[N] = {}, tp[N], dfn[N], cur = 0;
vector<int> e[N];

int dfs(int x, int pr) {
	
	d[x] = d[pr] + 1;
	fa[x] = pr;
	sz[x] = 1;
	for (auto i: e[x]) {
		if (i == pr)
			continue;
		sz[x] += dfs(i, x);
		if (sz[i] > sz[son[x]])
			son[x] = i;
	}
	return sz[x];
}
void srh(int x, int t) {
	dfn[x] = ++cur;
	tp[x] = t;
	if (son[x])
		srh(son[x], t);
	for (auto i: e[x])
		if (i != fa[x] && i != son[x])
			srh(i, i);
}

struct BIT {
	int tr[N];
	inline void mdf(int x, int v) {
		for (int i = x; i <= n; i += (i & -i))
			tr[i] += v;
	}
	inline int qry(int x) {
		int ret = 0;
		for (int i = x; i; i -= (i & -i))
			ret += tr[i];
		return ret;
	}
} bit;

int rt[N]; //rt[i]记录结点i平衡树的根结点 
mt19937 myrand(time(0));
struct Node {
	int l, r, sz, val, pri;
	Node() {
		l = r = sz = val = 0;
		pri = -1;
	}
	Node(int v) {
		l = r = 0;
		sz = 1;
		val = v;
		pri = myrand();
	}
};
struct FHQ_Treap {
	queue<int> q; //储存无用结点编号
	int n; 
	Node a[N * 2];
	
	int newNode(int v) {
		int id;
		if (!q.empty()) {
			id = q.front(), q.pop();
		}
		else
			id = ++n;
		a[id] = Node(v);
		return id;
	}
	void pushup(int x) {
		a[x].sz = a[a[x].l].sz + a[a[x].r].sz + 1;
	}
	void spt_val(int x, int v, int &L, int &R) {
		if (x == 0) {
			L = R = 0;
			return ;
		}
		if (a[x].val <= v) {
			L = x;
			spt_val(a[x].r, v, a[L].r, R);
		}
		else {
			R = x;
			spt_val(a[x].l, v, L, a[R].l);
		}
		pushup(x);
	} 
	int mrg(int L, int R) {
		if (L == 0 || R == 0)
			return L + R;
		if (a[L].pri > a[R].pri) {
			a[L].r = mrg(a[L].r, R);
			pushup(L);
			return L;
		}
		else {
			a[R].l = mrg(L, a[R].l);
			pushup(R);
			return R;
		}
	}
	int insrt(int x, int v) { //插入并返回新的根编号 
		int L, M = newNode(v), R;
		spt_val(x, v, L, R);
		return mrg(mrg(L, M), R);
	}
	int del(int x, int v) { //删除并返回新的根编号 
		int L, M, R;
		spt_val(x, v, L, R);
		spt_val(L, v - 1, L, M);
		q.push(M);
		return mrg(mrg(mrg(L, a[M].l), a[M].r), R);
	}
	int kth(int x, int k) {
		if (a[x].sz < k)
			return INF;
		if (a[a[x].l].sz + 1 == k)
			return a[x].val;
		if (a[a[x].l].sz + 1 > k)
			return kth(a[x].l, k);
		return kth(a[x].r, k - a[a[x].l].sz - 1);
	}
	void srh(int x) {
		if (x == 0)
			return ;
		srh(a[x].l);
		cout << a[x].val << ' ';
		srh(a[x].r);
	}
} tr;
//———————————————————————————— 
int getv(int x) {
	return bit.qry(dfn[x]);
}
void mdf(int x, int y, int v) {
	while (tp[x] != tp[y]) {
		if (d[tp[x]] < d[tp[y]])
			swap(x, y);
		int val = getv(tp[x]);
		bit.mdf(dfn[tp[x]], +v);
		bit.mdf(dfn[x] + 1, -v);
		
		//fa[tp[x]]要改 
		if (fa[tp[x]]) {
			rt[fa[tp[x]]] = tr.del(rt[fa[tp[x]]], val);
			rt[fa[tp[x]]] = tr.insrt(rt[fa[tp[x]]], val + v);
		}
		
		x = fa[tp[x]];
	}
	if (d[x] > d[y])
		swap(x, y);
	int val = getv(x);
	bit.mdf(dfn[x], +v);
	bit.mdf(dfn[y] + 1, -v);
	if (x == tp[x] && fa[x]) {
			rt[fa[x]] = tr.del(rt[fa[x]], val);
			rt[fa[x]] = tr.insrt(rt[fa[x]], val + v);
	}
}

struct Node2 {
	int val, cnt;
} p[10];
bool operator<(Node2 x, Node2 y) {
	return x.val < y.val;
}
int tmp[4];
int qry(int x, int y) {
	int v[4] = {0, getv(x), (son[x] ? getv(son[x]) : 2e9 + 10), (fa[x] ? getv(fa[x]) : 2e9 + 10)};
	sort(v + 1, v + 4);
	int tot = 0;
	for (int i = 1; i <= 3; i++)
		p[++tot] = {v[i], 1};
	int lst = 0;
	for (int i = max(1, y - 3); i <= y; i++)
		p[++tot] = {tr.kth(rt[x], i), i - lst}, lst = i;
	sort(p + 1, p + tot + 1);
	int nw = 0;
	for (int i = 1; i <= tot; i++) {
		nw += p[i].cnt;
		if(nw >= y)
			return p[i].val;
	}
}

inline int read()
{
    int x=0,fa=1;
    char ch;
    while(ch>'9'||ch<'0')
    {
        if(ch=='-')fa=-1;
        ch=getchar();
    }
    while('0'<=ch&&ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*fa;
}
                        
inline void write(int x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>=10)write(x/10);
    putchar(x%10+'0');
}

int a[N];

int main() {
//	freopen("1.in", "r", stdin);
//	freopen("1.out", "w", stdout);
	
	n = read(), q = read();
	for (int i = 1; i <= n; i++)
		a[i] = read();
	
	for (int i = 1, u, v; i < n; i++) {
		u = read(), v = read();
		e[u].push_back(v);
		e[v].push_back(u);
	}
	
	dfs(1, 0);
	srh(1, 1);
	
	for (int i = 1; i <= n; i++) {
		bit.mdf(dfn[i], a[i]);
		bit.mdf(dfn[i] + 1, -a[i]);
		for (auto j: e[i])
			if (j != fa[i] && j != son[i]) {
				rt[i] = tr.insrt(rt[i], a[j]);
			}
	}	
	while (q--) {
		int op = read();
		if (op == 1) {
			int x = read(), y = read(), z = read();
			mdf(x, y, z);
		}
		else {
			int x = read(), k = read();
			write(qry(x, k));
			putchar('\n');
		}
	}
	return 0;
}