//OccDreamer
#include<bits/stdc++.h>

#define vc vector
#define db double
#define fi first
#define se second
#define ll long long
#define mk make_pair
#define pb push_back
#define RI register int
#define PI pair<int,int>
#define ull unsigned long long
#define err cerr << "   -_-   " << endl
#define debug cerr << " ------------------- " << endl

#define input(x) freopen(#x".in","r",stdin)
#define output(x) freopen(#x".out","w",stdout)

#define NO puts("No")
#define YES puts("Yes")

//#define OccDreamer
//#define int long long

using namespace std;

namespace IO{
	inline int read(){
		int X=0, W=0; char ch=getchar();
		while(!isdigit(ch)) W|=ch=='-', ch=getchar();
		while(isdigit(ch)) X=(X<<1)+(X<<3)+(ch^48), ch=getchar();
		return W?-X:X;
	}
	inline void write(int x){
		if(x<0) x=-x, putchar('-');
		if(x>9) write(x/10);
		putchar(x%10+'0');
	}
	inline void sprint(int x){write(x), putchar(32);}
	inline void eprint(int x){write(x), putchar(10);}
}using namespace IO;

const int MAXN = 5e5+5;
const int mod = 998244353;

int anc[20][MAXN];
int mark[MAXN], son[MAXN], id[MAXN], tot;
int n, m, de[MAXN], topf[MAXN], siz[MAXN];
int head[MAXN], ne[MAXN<<1], to[MAXN<<1], fa[MAXN], cnt;

ll tag[MAXN<<2], tree[MAXN<<2];

vc<int> fail;
set<int> node[MAXN];

struct SGT{
	int minn[MAXN<<2], pos[MAXN<<2], tag[MAXN<<2]; 	
	inline void pushup(int p){
		minn[p]=min(minn[p<<1],minn[p<<1|1]);
		pos[p]=(minn[p]==minn[p<<1|1]?pos[p<<1|1]:pos[p<<1]);
		return ;
	}
	inline void pushdown(int p){
		tag[p<<1]+=tag[p];
		tag[p<<1|1]+=tag[p];
		minn[p<<1]+=tag[p];
		minn[p<<1|1]+=tag[p];
		return tag[p]=0, void();	
	}
	inline void build(int p, int l, int r){
		if(l==r) return minn[p]=de[mark[l]], pos[p]=l, void();
		int mid=(l+r)>>1;
		build(p<<1,l,mid); build(p<<1|1,mid+1,r);
		return pushup(p);	
	}
	inline void add(int p, int l, int r, int L, int R, int v){
		if(L<=l && r<=R) return minn[p]+=v, tag[p]+=v, void();
		int mid=(l+r)>>1; pushdown(p);
		if(L<=mid) add(p<<1,l,mid,L,R,v);
		if(R>mid) add(p<<1|1,mid+1,r,L,R,v);
		return pushup(p);
	}
}T;

struct BIT{
	ll tree[MAXN];
	inline int lowbit(int x){return x & -x;}
	inline void add(int x, ll v){while(x<=n) tree[x]+=v, x+=lowbit(x);}
	inline ll ask(int x){ll s=0; while(x) s+=tree[x], x^=lowbit(x); return s;}	
}t0, t1;

inline void add(int x, int y){++cnt;to[cnt]=y;ne[cnt]=head[x];head[x]=cnt;}

inline ll query(int x){return 1ll*(x+1)*t0.ask(x)-t1.ask(x);}

inline void add(int l, int r, int v){
	t0.add(l,v); t0.add(r+1,-v);
	t1.add(l,1ll*l*v); t1.add(r+1,-1ll*(r+1)*v);
	return ;
}

inline ll ask(int l, int r){return query(r)-query(l-1);}

inline void dfs(int x, int f){
	anc[0][x]=f; siz[x]=1;
	fa[x]=f; de[x]=de[f]+1; son[x]=0;
	for(int i=1;(1<<i)<=de[x];++i) anc[i][x]=anc[i-1][anc[i-1][x]];
	for(int i=head[x];i;i=ne[i]){
		if(to[i]==f) continue;
		dfs(to[i],x); siz[x]+=siz[to[i]];
		if(siz[to[i]]>siz[son[x]]) son[x]=to[i];
	}
	return ;
}

inline void dfs2(int x, int t){
	id[x]=++tot; topf[x]=t; mark[tot]=x;
	if(!son[x]) return ;
	dfs2(son[x],t);	
	for(int i=head[x];i;i=ne[i])
		if(to[i]!=fa[x] && to[i]!=son[x]) dfs2(to[i],to[i]);
	return ;
}

inline ll subsum(int x){return x==0?0:ask(id[x],id[x]+siz[x]-1);}

inline void upd(int x){
	int t=fa[x], y=son[t];
	if(subsum(x)>subsum(y)){
		son[t]=x; 
		T.add(1,1,n,id[y],id[y]+siz[y]-1,1);
		T.add(1,1,n,id[x],id[x]+siz[x]-1,-1);
		node[topf[y]].insert(id[y]);
		return ;
	}
	fail.pb(id[x]);
	return ;
}

inline void adjust(int x){
	while(x){
		int o=topf[x]; fail.clear();
		while(node[o].size() && *node[o].begin()<=id[x]) upd(mark[*node[o].begin()]), node[o].erase(node[o].begin());
		for(auto i:fail) node[o].insert(i); x=fa[o];
	}
	return ;
}

inline void Solve(){
	int p=mark[T.pos[1]];
	for(int i=19;i>=0;--i){
		if(anc[i][p]==0) continue;
		int o=anc[i][p];
		if(subsum(son[o])<=subsum(1)-subsum(o)) p=o;	
	}
	pair<ll,int> ans=mk(max(subsum(son[p]),subsum(1)-subsum(p)),id[p]);
	if(p!=1){
		p=fa[p];
		ans=min(ans,mk(max(subsum(son[p]),subsum(1)-subsum(p)),id[p]));	
	}
	eprint(mark[ans.se]);
}

signed main(){
	n=read(), m=read();
	for(int i=2;i<=n;++i){
		int x, y;
		x=read(), y=read();
		add(x,y), add(y,x);	
	}
	int op, x, y, z, a, b;
	dfs(1,0); dfs2(1,1); T.build(1,1,n);
	for(int i=2;i<=n;++i){
		if(son[fa[i]]!=i) node[topf[i]].insert(id[i]);
		else T.add(1,1,n,id[i],id[i]+siz[i]-1,-1);	
	}
	while(m--){
		op=read();
		if(op==1) x=read(), z=read(), add(id[x],id[x]+siz[x]-1,z), adjust(x);
		else{
			a=x=read(), b=y=read(), z=read();	
			while(topf[x]!=topf[y]){
				if(de[topf[x]]<de[topf[y]]) swap(x,y);
				add(id[topf[x]],id[x],z);
				x=fa[topf[x]];	
			}
			if(id[x]>id[y]) swap(x,y);
			add(id[x],id[y],z); adjust(a); adjust(b);
		}
		Solve();
	}
	return 0;
}