#include <algorithm>
#include <vector>
#include <cassert>

/*
 * @title HL分解
 * @docs docs/graph/heavy-light-decomposition.md
 */

struct heavy_light_decomposition {
    int n;
    std::vector<std::vector<int>> adj;
    std::vector<int> par, size, depth, in, out, head;
    heavy_light_decomposition(const std::vector<std::vector<int>> &adj)
        : n(adj.size()), adj(adj), par(n), size(n), depth(n), in(n), out(n), head(n) {}
    void dfs_size(int v, int p) {
        size[v] = 1;
        par[v] = p;
        if (p != -1) { depth[v] = depth[p] + 1; }
        for (int i = 0; i < adj[v].size(); i++) {
            int &u = adj[v][i];
            if (u == p) { continue; }
            dfs_size(u, v);
            size[v] += size[u];
            if (size[u] > size[adj[v][0]]) { std::swap(u, adj[v][0]); }
        }
    }
    int dfs_hld(int v, int &t) {
        in[v] = t++;
        for (int i = 0; i < adj[v].size(); i++) {
            int u = adj[v][i];
            if (u == par[v]) { continue; }
            head[u] = (i == 0 ? head[v] : u);
            dfs_hld(u, t);
        }
        return out[v] = t;
    }
    std::vector<int> build(int root) {
        dfs_size(root, -1);
        head[root] = root;
        int t = 0;
        dfs_hld(root, t);
        return in;
    }
    int get_lca(int u, int v) {
        while (true) {
            if (in[u] > in[v]) { std::swap(u, v); }
            if (head[u] == head[v]) { return u; }
            v = par[head[v]];
        }
    }
    int get_dist(int u, int v) { return depth[u] + depth[v] - 2 * depth[get_lca(u, v)]; }
    std::vector<std::pair<int, int>> get_path(int u, int v, bool edge) {
        std::vector<std::pair<int, int>> a, b;
        while (true) {
            if (head[u] == head[v]) {
                if (edge) {
                    if (in[u] > in[v]) { a.push_back({in[u], in[v] + 1}); }
                    if (in[u] < in[v]) { a.push_back({in[u] + 1, in[v]}); }
                } else { a.push_back({in[u], in[v]}); }
                break;
            }
            if (in[u] > in[v]) {
                a.push_back({in[u], in[head[u]]});
                u = par[head[u]];
            } else {
                b.push_back({in[head[v]], in[v]});
                v = par[head[v]];
            }
        }
        std::reverse(b.begin(), b.end());
        a.insert(a.end(), b.begin(), b.end());
        return a;
    }
    std::pair<int, int> get_subtree(int v, bool edge) {
        if (edge) {
            if (in[v] == out[v] - 1) { return {1, 0}; }
            return {in[v] + 1, out[v] - 1};
        }
        return {in[v], out[v] - 1};
    }
};

#include <vector>
#include <cassert>
#include <limits>

/*
 * @title 遅延評価セグメント木
 * @docs docs/data-structure/lazy-segment-tree.md
 */

template<typename M>
struct lazy_segment_tree {
    using T = typename M::T;
    using E = typename M::E;
    int n;
    std::vector<T> data;
    std::vector<E> lazy;
    lazy_segment_tree(int n) : n(n), data(n << 1, M::id_T()), lazy(n << 1, M::id_E()) {}
    lazy_segment_tree(const std::vector<T> &src) : n(src.size()), data(n << 1), lazy(n << 1, M::id_E()) {
        std::copy(src.begin(), src.end(), data.begin() + n);
        for (int i = n - 1; i > 0; i--) { data[i] = M::op_TT(data[i << 1 | 0], data[i << 1 | 1]); }
    }
    void propagate(int i) {
        if (i < 1) { return; }
        data[i] = M::op_TE(data[i], lazy[i]);
        if (i < n) {
            lazy[i << 1 | 0] = M::op_EE(lazy[i << 1 | 0], lazy[i]);
            lazy[i << 1 | 1] = M::op_EE(lazy[i << 1 | 1], lazy[i]);
        }
        lazy[i] = M::id_E();
    }
    void add(int l, int r, const E &x) {
        assert(0 <= l && l < n);
        assert(0 < r && r <= n);
        l += n, r += n - 1;
        for (int i = std::__lg(r); i > 0; i--) {
            propagate(l >> i);
            propagate(r >> i);
        }
        static auto apply = [&](int i) { lazy[i] = M::op_EE(lazy[i], x), propagate(i); };
        for (int i = l, j = r + 1; i < j; i >>= 1, j >>= 1) {
            if (i & 1) { apply(i++); }
            if (j & 1) { apply(--j); }
        }
        while (l >>= 1, r >>= 1) {
            data[l] = M::op_TT(M::op_TE(data[l << 1 | 0], lazy[l << 1 | 0]),
                               M::op_TE(data[l << 1 | 1], lazy[l << 1 | 1]));
            data[r] = M::op_TT(M::op_TE(data[r << 1 | 0], lazy[r << 1 | 0]),
                               M::op_TE(data[r << 1 | 1], lazy[r << 1 | 1]));
        }
    }
    T get_sum(int l, int r) {
        assert(0 <= l && l < n);
        assert(0 < r && r <= n);
        l += n, r += n - 1;
        for (int i = std::__lg(r); i > 0; i--) { propagate(l >> i), propagate(r >> i); }
        T a = M::id_T(), b = M::id_T();
        for (r++; l < r; l >>= 1, r >>= 1) {
            if (l & 1) { propagate(l), a = M::op_TT(a, data[l++]); }
            if (r & 1) { propagate(--r), b = M::op_TT(data[r], b); }
        }
        return M::op_TT(a, b);
    }
};

struct rminq_and_ruq {
    using T = int;
    using E = int;
    static T id_T() { return std::numeric_limits<T>::max(); };
    static E id_E() { return -1; };
    static T op_TT(const T &a, const T &b) { return std::min(a, b); }
    static E op_EE(const E &a, const E &b) { return b == id_E() ? a : b; }
    static T op_TE(const T &a, const E &b) { return b == id_E() ? a : b; }
};

struct rsq_and_raq {
    using T = std::pair<int, int>;
    using E = int;
    static T id_T() { return {0, 0}; };
    static E id_E() { return 0; };
    static T op_TT(const T &a, const T &b) { return {a.first + b.first, a.second + b.second}; }
    static E op_EE(const E &a, const E &b) { return a + b; }
    static T op_TE(const T &a, const E &b) { return {a.first + b * a.second, a.second}; }
};

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N, Q;
    cin >> N >> Q;
    vector<vector<int>> adj(N);
    for (int i = 0; i < N - 1; i++) {
        int a, b;
        cin >> a >> b;
        adj[a].push_back(b), adj[b].push_back(a);
    }
    heavy_light_decomposition hld(adj);
    hld.build(0);
    using ll = long long;
    struct rsq_and_raq_ll {
        using T = std::pair<ll, int>;
        using E = ll;
        static T id_T() { return {0, 0}; };
        static E id_E() { return 0; };
        static T op_TT(const T &a, const T &b) { return {a.first + b.first, a.second + b.second}; }
        static E op_EE(const E &a, const E &b) { return a + b; }
        static T op_TE(const T &a, const E &b) { return {a.first + b * a.second, a.second}; }
    };
    lazy_segment_tree<rsq_and_raq_ll> lst(vector<pair<ll, int>>(N, {0, 1}));
    for (int i = 0; i < Q; i++) {
        int type;
        cin >> type;
        if (type == 0) {
            int u, v;
            cin >> u >> v;
            ll ans = 0;
            vector<pair<int, int>> segs = hld.get_path(u, v, true);
            for (int j = 0; j < segs.size(); j++) {
                if (segs[j].first > segs[j].second) { swap(segs[j].first, segs[j].second); }
                ans += lst.get_sum(segs[j].first, segs[j].second + 1).first;
            }
            cout << ans << endl;
        } else {
            int v, x;
            cin >> v >> x;
            pair<int, int> seg = hld.get_subtree(v, true);
            lst.add(seg.first, seg.second + 1, x);
        }
    }
}


Measured memory_bytes: 38164