#include<bits/stdc++.h>
//zhouAKngyang 神
//zhouAKngyang 神
//zhouAKngyang 神 
#define sz(a) ((int) (a).size())
using namespace std;
typedef unsigned long long ll;
typedef pair<int, int> pii;
typedef vector<pii> VC;
const int P = 998244353;
const int N = 2e5+5;
template<typename T>inline void read(T &a)
{
	a = 0;
	int f = 1;
	char c = getchar();
	while(!isdigit(c))
	{
		if(c == '-')	f = -1;
		c = getchar();
	}
	while(isdigit(c))
		a = a * 10 + c - 48,c = getchar();
	a *= f;
}

template<typename T,typename ...L> inline void read(T &a,L &...l)
{
	read(a),read(l...);
}

const int K = 4; 
int n, m, u, op, x, y, k, v, fa[N], up[N], sze[N], dfn[N], timestamp, dep[N];
VC kson[N][K], kdis[N][K], fh[N][K], sub[N], kans[N][K];

/*
五个数组分别是：恰好为 k 阶的儿子，距离一个点在k以内的点，父亲除了自己以外的恰好k阶儿子，子树信息，一个点到根的链及其距离为k以内的点。 
*/ 

vector<int> G[N], sons[N];

inline void mg(VC &o) {
	VC ans;
	sort(o.begin(), o.end());
	for(auto it:o) {
		if(ans.size() && ans.back().second + 1 == it.first) {
			ans.back().second = it.second;
		}
		else {
			ans.emplace_back(it); 
		}
	} 
	o = ans;//对不相交线段进行合并 
}

inline VC getdel(int x, int y, int k) {//在x中去掉y得到答案。注意这里y一定是x的一个子集 
	VC u = kans[x][k], v = kans[y][k];
	sort(u.begin(), u.end()), sort(v.begin(), v.end());
	int l = 0;
	VC ans;
	for(auto it:u) {
		while(l < sz(v) && v[l].second < it.first) {
			l++;
		}
		int r = l;
		while(r < sz(v) && v[r].second <= it.second)  {
			r++;
		}
		if(l == r) {
			ans.emplace_back(it);
		}
		else {
			int lstl = it.first;
			for(int i = l; i < r; i++) {
				if(v[i].first > lstl) {
					ans.emplace_back(lstl, v[i].first - 1);
				}
				lstl = v[i].second + 1;
			}
			if(lstl <= it.second) {
				ans.emplace_back(lstl, it.second); 
			}
		}
	}
	return ans;
}

struct BIT {
	ll a[N], b[N];
	
	inline void mdf(int x, int v) {
		ll xx = x;
		for(; x < N; x += x & -x) {
			a[x] += v, b[x] += xx * v;
		}
	}
	
	void add(int l, int r, int x) {
		//cerr<<l<<' '<<r<<' '<<x<<"??\n";
		mdf(l, x), mdf(r + 1, -x);
	}
	
	inline ll sum(int x) {
		ll xx = x;
		ll ansa = 0, ansb = 0;
		for(; x; x -= x & -x) {
			ansa += a[x], ansb += b[x];
		}
		return (xx + 1) * ansa - ansb;
	}
	
	ll query(int l, int r) {
		//cerr<<l<<' '<<r<<endl; 
		return sum(r) - sum(l - 1);
	}
}bit;

inline int LCA(int a, int b) {
	while(up[a] != up[b]) {
		if(dep[up[a]] > dep[up[b]]) swap(a, b);
		b = fa[up[b]];
	}
	return dep[a] < dep[b] ? a : b;
}

void DFS1(int u, int f) {
	fa[u] = f, sze[u] = 1, dep[u] = dep[f] + 1;
	for(auto it:G[u]) {
		if(it == f) continue;
		DFS1(it, u);
		sze[u] += sze[it];
		sons[u].emplace_back(it);
	}
	sort(sons[u].begin(), sons[u].end(), [&](int a, int b) {
		return sze[a] > sze[b];
	});
}

void iter(int u, int i) {
	if(i == 1) {
		if(!dfn[u]) {
			dfn[u] = ++timestamp;
		}
		return;
	}
	for(auto it:sons[u]) {
		iter(it, i - 1);//相当于BFS的过程 
	}
}

void DFS2(int u) {//这里的参数一定是所有重链的端点
	vector<int> heavy;
	for(int uu = u; uu; uu = sons[uu][0]) {
		up[uu] = u;
		heavy.emplace_back(uu);
		if(!dfn[uu]) {
			dfn[uu] = ++timestamp;
		}
		if(!sz(sons[uu])) {
			break;
		}
	} 
	for(int i = 1; i <= 3; i++) {
		for(auto uu:heavy) {
			for(int j = 1; j < sz(sons[uu]); j++) {
				iter(sons[uu][j], i);//从uu开始迭代三层 
			} 
		}
	}
	for(auto uu:heavy) {
		for(int j = 1; j < sz(sons[uu]); j++) {
			DFS2(sons[uu][j]);
		}
	}
}

void operator += (VC &A, VC B) {
	for(auto it:B) {
		A.emplace_back(it);
	} 
	mg(A);
} 

void DFS3(int u) {//it's really magic... 
	pii now = make_pair(dfn[u], dfn[u]);
	kson[u][0].emplace_back(now);
	sub[u].emplace_back(now);
	for(auto it:sons[u]) {
		DFS3(it);
		sub[u] += sub[it];
		for(int j = 0; j < K; j++) {
			fh[it][j] += kson[u][j];
		}
		for(int j = 1; j < K; j++) {
			kson[u][j] += kson[it][j - 1];
		} 
	}
	VC tmp[K];
	for(int t = sz(sons[u]) - 1; t >= 0; t--) {
		int it = sons[u][t];
		for(int j = 0; j < K; j++) {
			fh[it][j] += tmp[j];//倒序循环，j级儿子 
		} 
		for(int j = 1; j < K; j++) {
			tmp[j] += kson[it][j - 1];
		}
	}
} 

void DFS4(int u) {
	for(int i = 0; i < K; i++) {
		kans[u][i] = kson[u][i];
		kans[u][i] += kans[fa[u]][i];//这是最神仙的一步！
		//这里看似没有统计到距离1小于k的位置，但是由于是两个变量作差，所以没有影响。 
	}
	for(auto it:sons[u]) {
		DFS4(it); 
	} 
	for(int i = 0; i < K; i++) {
		for(int j = 0; j <= i; j++) {
			kdis[u][i] += kson[u][j];
		}
		int uu = u;
		for(int j = i - 1; j >= 0; j--) {
			for(int k = 0; k <= j; k++) {
				kdis[u][i] += fh[uu][k];
			}
			uu = fa[uu];
		}
	}
} 

VC split(int x, int y, int k) {
	int l = LCA(x, y);
	VC ans = getdel(x, l, k);
	ans += getdel(y, l, k);
	ans += kdis[l][k];
	return ans; 
}

inline VC get_son(int u) {
	return sub[u];
}

int main() {
	read(n, m);
	for(int i = 1; i < n; i++) {
		read(u, v);
		G[u].emplace_back(v), G[v].emplace_back(u);
	}
	DFS1(1, 0), DFS2(1), DFS3(1), DFS4(1); 
	for(int i = 1; i <= m; i++) {
		read(op);
		switch(op) {
			case 1: {//链 
				read(x, y, k, v);
				VC now = split(x, y, k);
				for(auto it:now) {
					bit.add(it.first, it.second, v);
				}
				break;
			}
			case 2: {//子树 
				read(x, v); 
				VC now = get_son(x);
				for(auto it:now) {
					bit.add(it.first, it.second, v);
				}
				break;
			}
			case 3: {//查询链 
				read(x, y, k);
				VC now = split(x, y, k); 
				ll ans = 0;
				for(auto it:now) {
					ans += bit.query(it.first, it.second);
				}
				printf("%llu\n", ans);
				break;
			}
			case 4: {//查询子树 
				read(x); 
				VC now = get_son(x);
				ll ans = 0;
				for(auto it:now) {
					ans += bit.query(it.first, it.second);
				} 
				printf("%llu\n", ans);
				break;
			}
		}
	}
} 

/*
	start coding at:2024/2/17 19:55 
	finish debugging at:2024/2/17 22:06
	stubid mistakes:没有调用DFS，跳重链的终止条件是sze非零，DFS2(sons[uu][j])而不是 DFS2(j)，查询前应该找回原来的xx，求kdis的时候要累加父亲的所有fh的贡献（不能是一个） 
*/

/*
  吾日三省吾身：
  你排序了吗？
  你取模了吗？
  你用%lld输出long long 了吗？
  1LL<<x写对了吗？
  判断=0用了abs()吗？
  算组合数判了a<b吗？
  线段树build()了吗？
  .size()加了(signed)吗？
  树链剖分的DFS序是在第二次更新的吗？
  修改在询问前面吗？
  线段树合并到叶子结点return了吗？
  __builtin_ctz后面需要加ll吗？
  可撤销并查集真的要路径压缩吗？
*/