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

template <typename T>
class SparseTable {
	int n;
	vector<vector<T>> t;
	T merge(const T& l, const T& r) {
		return min(l, r);
	}
public:
	SparseTable(const vector<T>& b) {
		n = b.size();
		t.push_back(b);
		for (int i = 2, j = 1; i <= n; i <<= 1, j++) {
			t.push_back(vector<T>());
			for (int k = 0; k + i <= n; k++) {
				t[j].push_back(merge(t[j - 1][k], t[j - 1][k + i / 2]));
			}
		}
	}
	T find(int l, int r) {
		unsigned int w = r - l;
		int i = 31 - __builtin_clz(w);
		return merge(t[i][l], t[i][r - (1 << i)]);
	}
	T operator[](int id) {
		return t[0][id];
	}
};

class LCA {
	using pii = pair<int, int>;
	int V, rt;
	vector<vector<int>> G;
	vector<int> depth, used, id;
	vector<int> vs, de;
	SparseTable<pii> st;
	void dfs(int s, int d) {
		used[s] = 1;
		vs.push_back(s);
		de.push_back(d);
		for (int v : G[s]) {
			if (!used[v]) {
				dfs(v, d + 1);
				vs.push_back(s);
				de.push_back(d);
			}
		}
	}
	vector<pii> init() {
		dfs(rt, 0);
		for (int i = 0; i < (int)vs.size(); i++) {
			if (id[vs[i]] == -1) id[vs[i]] = i;
		}
		vector<pii> r((int)vs.size());
		for (int i = 0; i < (int)vs.size(); i++) {
			r[i] = pii(de[i], vs[i]);
		}
		return r;
	}
public:
	LCA(const graph& G_, int rt_ = 0)
		: V(G_.size()), rt(rt_), G(G_), depth(V), used(V), id(V, -1), st(init()) {
		for (int i = 0; i < V; i++) depth[i] = st[id[i]].first;
	}
	int calc(int a, int b) {
		return st.find(min(id[a], id[b]), max(id[a], id[b]) + 1).second;
	}
	int dist(int a, int b) {
		return depth[a] + depth[b] - depth[calc(a, b)] * 2;
	}
};

template <typename T>
class FenwickTree {
	const int n;
	vector<T> data;
public:
	FenwickTree(int n_) : n(n_), data(n) {}
	T find(int p) const {
		T res = 0;
		while (p >= 0) {
			res += data[p];
			p = (p & (p + 1)) - 1;
		}
		return res;
	}
	void add(int p, T val) {
		while (p < n) {
			data[p] += val;
			p |= p + 1;
		}
	}
};

template <typename T>
class RARS {
	const int n;
	FenwickTree<T> bit0, bit1;
public:
	RARS(int n_) : n(n_), bit0(n), bit1(n) {}
	T find(int p) const {
		return bit1.find(p) * (p + 1) + bit0.find(p);
	}
	T find(int l, int r) const {
		return find(r - 1) - find(l - 1);
	}
	void add(int l, int r, T val) {
		bit0.add(l, -val * l);
		bit1.add(l, val);
		bit0.add(r, val * r);
		bit1.add(r, -val);
	}
};

const int MAX = 150000;

int acnt, scnt;
int la[MAX], ra[MAX], ls[MAX], rs[MAX];

void euler_tour(int v, int prev, const graph& G) {
	la[v] = acnt;
	ls[v] = scnt;
	for (auto to : G[v]) if (to != prev) {
		acnt++;
		euler_tour(to, v, G);
		scnt++;
	}
	ra[v] = acnt;
	rs[v] = scnt;
}

int main()
{
	ios::sync_with_stdio(false), cin.tie(0);
	int N, Q;
	cin >> N >> Q;
	graph G(N);
	for (int i = 0; i < N - 1; i++) {
		int a, b;
		cin >> a >> b;
		G[a].push_back(b);
		G[b].push_back(a);
	}
	euler_tour(0, -1, G);
	LCA lca(G, 0);
	RARS<ll> add(N - 1), sub(N - 1);
	while (Q--) {
		int t, u, v;
		cin >> t >> u >> v;
		if (t == 0) {
			int p = lca.calc(u, v);
			printf("%lld\n", (add.find(la[p], la[u]) + sub.find(ls[p], ls[u])) + (add.find(la[p], la[v]) + sub.find(ls[p], ls[v])));
		}
		else {
			add.add(la[u], ra[u], v);
			sub.add(ls[u], rs[u], -v);
		}
	}
	return 0;
}



Measured memory_bytes: 81872