/*

Even with one's eyes closed, heaven is there.

As long as heaven is lodged in,
there is no way to avert your gaze
from what you wish not to see.

Meaning, you may only see
what it wants you to see.

Even though one's eyes were closed,
one's sight remained open.

It will be forever impossible to close.

*/
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 3e5 + 5;
int n, q, srt[N];
vector<int> e[N];
int fa[N], de[N], sz[N], son[N];
int top[N], dfsnum, dfn[N], rev[N];
ll a[N];
set<pair<int, int>> st[N];
void dfs1(int u){
	sz[u] = 1;
	for (int v : e[u])
		if (v != fa[u]){
			fa[v] = u;
			de[v] = de[u] + 1;
			dfs1(v);
			sz[u] += sz[v];
			if (sz[v] > sz[son[u]])
				son[u] = v;
		}
}
void dfs2(int u){
	rev[dfn[u] = ++dfsnum] = u;
	if (son[u]){
		top[son[u]] = top[u];
		dfs2(son[u]);
	}
	for (int v : e[u])
		if (v != fa[u] && v != son[u]){
			top[v] = v;
			dfs2(v);
		}
}
void dfs3(int u){
	st[u].insert({sz[u], u});
	for (int v : e[u])
		if (v != fa[u]){
			dfs3(v);
			if (st[u].size() < st[v].size()) swap(st[u], st[v]);
			for (pair<int, int> p : st[v]) st[u].insert(p);
			st[v].clear();
		}
	while (st[u].begin()->first * 2 <= sz[u]) st[u].erase(st[u].begin());
	srt[u] = st[u].begin()->second;
}
int kfa(int u, int k){
	k = de[u] - k;
	while (de[top[u]] - 1 >= k) u = fa[top[u]];
	return rev[dfn[u] - (de[u] - k)];
}
int lca(int u, int v){
	while (top[u] != top[v]){
		if (de[top[u]] < de[top[v]]) swap(u, v);
		u = fa[top[u]];
	}
	return de[u] < de[v] ? u : v;
}
vector<pair<int, int>> getpath(int u, int v){
	vector<pair<int, int>> res;
	while (top[u] != top[v]){
		if (de[top[u]] < de[top[v]]) swap(u, v);
		res.emplace_back(dfn[top[u]], dfn[u]);
		u = fa[top[u]];
	}
	if (dfn[u] > dfn[v]) swap(u, v);
	res.emplace_back(dfn[u], dfn[v]);
	return res;
}
struct tree{
	ll a[N];
	void add(int x, ll k){
		for (; x <= n; x += x & -x) a[x] += k;
	}
	ll ask(int x){
		ll res = 0;
		for (; x; x -= x & -x) res += a[x];
		return res;
	}
}T, Ts, Td;
void add(int l, int r, ll k){
	T.add(l, k);
	T.add(r + 1, -k);
}
void addsz(int l, int r, ll k){
	Ts.add(l, k);
	Ts.add(r + 1, -k);
}
void addde(int l, int r, ll k){
	Td.add(l, k);
	Td.add(r + 1, -k);
}
ll ask(int u){
	return T.ask(dfn[u]) + Td.ask(dfn[u]) * de[u] + Ts.ask(dfn[u]) * sz[u];
}
int step(int u){
	if (ask(1) <= 0) return 1;
	if (u > 1 && ask(u) <= 0){
		while (top[u] != 1 && ask(top[u]) <= 0) u = fa[top[u]];
		int l = dfn[top[u]], r = dfn[u], mid;
		while (l <= r){
			mid = (l + r) >> 1;
			if (ask(rev[mid]) <= 0) r = mid - 1;
			else l = mid + 1;
		}
		u = rev[r];
	}
	return u;
}
int main(){
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//	freopen("in.txt", "r", stdin);
//	freopen("out.txt", "w", stdout);
	cin >> n >> q;
	for (int i = 1; i < n; i++){
		int u, v;
		cin >> u >> v;
		e[u].push_back(v);
		e[v].push_back(u);
	}
	dfs1(1);
	top[1] = 1;
	dfs2(1);
	dfs3(1);
	int ans = 1;
	while (q--){
		int opt, u, val, mid;
		cin >> opt >> u;
		if (opt == 1){
			mid = srt[u];
			cin >> val;
			add(1, dfn[u] - 1, -1ll * sz[u] * val);
			if (u > 1){
				vector<pair<int, int>> vec = getpath(1, fa[u]);
				for (pair<int, int> p : vec){
					int l = p.first, r = p.second;
					add(l, r, 2ll * sz[u] * val);
				} 
			}
			add(dfn[u], dfn[u] + sz[u] - 1, -1ll * sz[u] * val);
			addsz(dfn[u], dfn[u] + sz[u] - 1, 2 * val);
			add(dfn[u] + sz[u], n, -1ll * sz[u] * val);
		}else{
			int v;
			cin >> v >> val;
			int l = lca(u, v), len = de[u] + de[v] - 2 * de[l] + 1;
			if (len & 1) mid = kfa(de[u] > de[v] ? u : v, len / 2);
			else mid = kfa(de[u] > de[v] ? u : v, len / 2);
			add(1, dfn[l], -1ll * len * val);
			vector<pair<int, int>> vec = getpath(1, l);
			for (pair<int, int> p : vec){
				int l2 = p.first, r2 = p.second;
				add(l2, r2, 2ll * len * val);
			}
			add(dfn[l] + 1, dfn[l] + sz[l] - 1, -1ll * len * val);
			if (u != l){
				vec = getpath(u, kfa(u, de[u] - de[l] - 1));
				for (pair<int, int> p : vec){
					int l2 = p.first, r2 = p.second;
					add(l2, r2, 2ll * (de[u] + 1) * val);
					addde(l2, r2, -2 * val);
				}
			}
			if (v != l){
				vec = getpath(v, kfa(v, de[v] - de[l] - 1));
				for (pair<int, int> p : vec){
					int l2 = p.first, r2 = p.second;
					add(l2, r2, 2ll * (de[v] + 1) * val);
					addde(l2, r2, -2 * val);
				}
			}
			add(dfn[l] + sz[l], n, -1ll * len * val);
		}
//		for (int i = 2; i <= n; i++) cout << ask(i) << ' ';
//		cout << endl;
		ans = step(ans);
		mid = step(mid);
		if (de[mid] > de[ans]) ans = mid;
		cout << ans << endl;
//		pair<int, int> mx(-1, 1);
//		for (int i = 2; i <= n; i++)
//			if (ask(i) > 0)
//				mx = max(make_pair(de[i], i), mx);
//		cout << mx.second << endl;
	}
	return 0;
}