#define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
using namespace std;
#include <iostream>
#include <vector>
#include <utility>
#include <map>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <tuple>
#define DEBUG
typedef long long ll;
// #define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
#define all(c) begin(c), end(c)
#define range(i,a,b) for(int i = a; i < (int)(b); i++)
#define rep(i,b) range(i,0,b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
namespace std {
    template<class T> ostream & operator << (ostream &os, const vector<T> &);
    template<size_t n, class...T>
    typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &, tuple<T...> const &, const char *) {}
    template<size_t n, class...T> typename enable_if < (n < sizeof...(T))>::type _ot(ostream &os, tuple<T...> const &t, const char *delim) {
        os << (n == 0 ? "" : delim) << get<n>(t); _ot<n + 1>(os, t, delim);
    }
    template<class...T> ostream &operator << (ostream &os, const tuple<T...> &t) {
        _ot<0>(os, t, ", "); return os;
    }
    template<class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p) {
        return os << "(" << p.first << ", " << p.second << ") ";
    }
    template<class T>
    ostream & operator<<(ostream &os, const vector<T> &v) {
        os << "{ ";
        for (auto it = v.cbegin(); it != v.cend(); ++it) os << *it << (it + 1 == v.cend() ? "" : ", ");
        return os << " }";
    }
}

#ifdef  DEBUG
#define dump(...) (cerr << #__VA_ARGS__ << " = " << make_tuple(__VA_ARGS__) << " (L:" << __LINE__ << ")" << endl)
#else
#define dump(...)
#endif
void fastios() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    // #define endl '\n'
}

ll const mod = 1000000007;
auto const inf = numeric_limits<int>::max() / 8;

template<class T>
struct SegmentTree {
    vector<T> dat, lazy;
    int n, ql, qr;
    size_t size_;
    SegmentTree(int n_) : size_(n_) {
        n = 1;
        while (n < n_) n <<= 1;
        dat = vector<T>(n + n);
        lazy = vector<T>(n + n);
    }
    void pushdown(int v, int nl, int nr) {
        dat[v] += lazy[v] * (nr - nl);
        if (v < n) {
            lazy[v << 1] += lazy[v];
            lazy[v << 1 | 1] += lazy[v];
        }
        lazy[v] = 0;
    }
    void pullup(int v) {
        dat[v] = dat[v << 1] + dat[v << 1 | 1];
    }
    void add(int n, int nl, int nr, const T &x) {
        pushdown(n, nl, nr);
        if (nr <= ql || qr <= nl) {
            return;
        }
        else if (ql <= nl && nr <= qr) {
            lazy[n] += x;
            pushdown(n, nl, nr);
        }
        else {
            int m = (nl + nr) / 2;
            add(n << 1, nl, m, x);
            add(n << 1 | 1, m, nr, x);
            pullup(n);
        }
    }
    void add(int l, int r, const T &x) {
        ql = l; qr = r;
        return add(1, 0, size(), x);
    }
    T sum(int n, int nl, int nr) {
        pushdown(n, nl, nr);
        if (nr <= ql || qr <= nl) {
            return 0;
        }
        else if (ql <= nl && nr <= qr) {
            return dat[n];
        }
        else {
            int m = (nl + nr) / 2;
            T l = sum(n << 1, nl, m);
            T r = sum(n << 1 | 1, m, nr);
            pullup(n);
            return l + r;
        }
    }
    T sum(int l, int r) {
        ql = l; qr = r;
        return sum(1, 0, size());
    }
    size_t size() const { return size_; }
    vector<T> to_a(int l = -1, int r = -1) {
        if (l == -1) l = 0;
        if (r == -1) r = size();
        vector<T> res(r - l);
        for (int i = l; i < r; i++) res[i - l] = sum(i, i + 1);
        return res;
    }
};

struct HeavyLightDecomposition {
    int size;
    vector<vector<int>> g;
    vector<int> parent, subtreeSize, depth;
    vector<int> head, last, next, prev;
    vector<int> chain, at;
    vector<vector<int>> chains;

    template<class Graph>
    HeavyLightDecomposition(const Graph &g_) {
        size = g_.size();
        g.resize(size);
        vector<int64_t> es;
        for (size_t i = 0; i < g_.size(); i++) {
            for (auto &e : g_[i]) {
                int a = e.src, b = e.dst;
                if (a > b) swap(a, b);
                es.push_back((int64_t)a << 32 | b);
            }
        }
        sort(es.begin(), es.end());
        es.erase(unique(es.begin(), es.end()), es.end());
        for (auto & e : es) addEdge(e >> 32, e & 0xFFFFFFFF);
    }

    HeavyLightDecomposition(int n_) : size(n_), g(n_) {}

    void addEdge(int a, int b) {
        g[a].push_back(b);
        g[b].push_back(a);
    }

    int goUp(int & v) const {
        return parent[head[v]];
    }

    pair<int, int> getIndex(int v) const {
        return make_pair(chain[v], at[v]);
    }

    void decompose(const int root = 0) {
        parent.assign(size, 0);
        subtreeSize.assign(size, 0);
        depth.assign(size, -1);
        head.assign(size, 0);
        last.assign(size, 0);
        next.assign(size, -1);
        prev.assign(size, -1);
        chain.assign(size, -1);
        at.assign(size, 0);
        static int stk[600010], k = 0;
        stk[k++] = root;
        parent[root] = -1;
        depth[root] = 0;
        while (k) {
            const int v = stk[--k];
            if (v >= 0) {
                stk[k++] = ~v;
                for (const int ch : g[v]) {
                    if (depth[ch] != -1) continue;
                    depth[ch] = depth[v] + 1;
                    parent[ch] = v;
                    stk[k++] = ch;
                }
            }
            else {
                const int u = ~v;
                subtreeSize[u] = 1;
                int m = 0;
                for (const int ch : g[u]) {
                    if (parent[u] == ch) continue;
                    subtreeSize[u] += subtreeSize[ch];
                    if (m < subtreeSize[ch]) {
                        m = subtreeSize[ch];
                        next[u] = ch;
                    }
                }
            }
        }

        k = 0;
        stk[k++] = root;
        while (k) {
            const int head_ = stk[--k];
            for (const int ch : g[head_]) {
                if (parent[head_] == ch) continue;
                stk[k++] = ch;
            }
            if (chain[head_] != -1) continue;
            chains.push_back(vector<int>());
            vector<int> & path = chains.back();
            int cur = head_;
            while (cur != -1) {
                path.push_back(cur);
                cur = next[cur];
            }
            for (size_t i = 0; i < path.size(); i++) {
                const int v = path[i];
                head[v] = path.front();
                last[v] = path.back();
                next[v] = i + 1 != path.size() ? path[i + 1] : -1;
                prev[v] = i != 0 ? path[i - 1] : -1;
                chain[v] = chains.size() - 1;
                at[v] = i;
            }
        }
    }

    void buildSegTree() {
        segtrees.clear();
        rep(i, chains.size()) {
            segtrees.push_back(SegmentTree<ll>(chains[i].size()));
        }
    }

    int lca(int u, int v) {
        while (chain[u] != chain[v]) {
            if (depth[head[u]] > depth[head[v]]) u = goUp(u);
            else v = goUp(v);
        }
        return depth[u] < depth[v] ? u : v;
    }

    vector<SegmentTree<ll>> segtrees;
    ll solve(int u, int v) {
        int l = lca(u, v);
        return climb(u, 0) + climb(v, 0) - 2*climb(l, 0);
    }
    ll climb(const int u, const int l) {
        ll res = 0;
        int v = u;
        while (chain[v] != chain[l]) {
            int c, k;
            tie(c, k) = getIndex(v);
            res += segtrees[c].sum(0, k);
            int pp = goUp(v);
            if (pp != -1) {
                res += segtrees[chain[pp]].sum(at[pp], at[pp] + 1) * (depth[u] - depth[pp]);
            }
            v = pp;
        }
        res += segtrees[chain[l]].sum(at[l], at[v]);
        return res;
    }
    void add(int u, ll x) {
        int c, k;
        tie(c, k) = getIndex(u);
        segtrees[c].add(k, chains[c].size(), x);
    }
};

int main() {
    fastios();
    int n, q;
    cin >> n >> q;
    HeavyLightDecomposition hld(n);
    rep(i, n-1) {
        int a, b;
        cin >> a >> b;
        hld.addEdge(a, b);
    }
    hld.decompose();
    hld.buildSegTree();
    rep(i, q) {
        int t;
        cin >> t;
        if (t == 0) {
            int u, v;
            cin >> u >> v;
            cout << hld.solve(u, v) << '\n';
        }
        else {
            int v, x;
            cin >> v >> x;
            hld.add(v, x);
        }
    }
}

Measured memory_bytes: 52252