#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

constexpr int N = 2e5 + 9;
constexpr int K = 3;
int n, m;

int fa[N], sz[N], son[N], dfn[N], dfc, st[18][N], idx[N], cnt;
vi g[N];

IL int cp (int x, int y) {
  return dfn[x] < dfn[y] ? x : y;
}

IL int lca (int x, int y) {
  if (x == y) {
    return x;
  }
  if ((x = dfn[x]) > (y = dfn[y])) {
    swap(x, y);
  }
  int i = 31 ^ __builtin_clz(y - x++);
  return cp(st[i][x], st[i][y - (1 << i) + 1]);
}

void dfs1 (int u) {
  sz[u] = 1;
  st[0][dfn[u] = ++dfc] = fa[u];
  if (fa[u]) {
    g[u].erase(find(g[u].begin(), g[u].end(), fa[u]));
  }
  for (int v : g[u]) {
    fa[v] = u;
    dfs1(v);
    sz[u] += sz[v];
    if (sz[v] > sz[son[u]]) {
      son[u] = v;
    }
  }
}

void spread (int u, int k) {
  if (k == 0) {
    if (!idx[u]) {
      idx[u] = ++cnt;
    }
    return;
  }
  for (int v : g[u]) {
    spread(v, k - 1);
  }
}

void dfs2 (int u) {
  vi way;
  for (int v = u; v; v = son[v]) {
    way.eb(v);
  }
  L (i, 0, K) {
    for (int x : way) {
      spread(x, i);
    }
  }
  for (int x : way) {
    for (int y : g[x]) {
      if (y != son[x]) {
        dfs2(y);
      }
    }
  }
}

using vp = vector<pair<int, int>>;

void join (vp &a, const vp &b) {
  a.insert(a.end(), b.begin(), b.end());
}

void up (vp &a) {
  sort(a.begin(), a.end());
  vp b;
  for (auto &x : a) {
    if (x.first <= x.second) {
      if (!b.empty() && x.first <= b.back().second + 1) {
        b.back().second = max(b.back().second, x.second);
      } else {
        b.eb(x);
      }
    }
  }
  a.swap(b);
}

vp sub[N], ksub[N][K + 1], kup[N][K + 1], fd[N][K + 1], kb[N][K + 1];

void dfs3 (int u) {
  ksub[u][0] = sub[u] = {make_pair(idx[u], idx[u])};
  for (int v : g[u]) {
    dfs3(v);
    join(sub[u], sub[v]);
    L (i, 0, K) {
      up(ksub[u][i]);
      kb[v][i] = ksub[u][i];
    }
    L (i, 1, K) {
      join(ksub[u][i], ksub[v][i - 1]);
    }
  }
  L (i, 0, K) {
    up(ksub[u][i]);
  }
  up(sub[u]);
  if (sz(g[u]) > 1) {
    array<vp, 4> suf{};
    R (i, sz(g[u]) - 1, 0) {
      int v = g[u][i];
      L (j, 0, K) {
        up(suf[j]);
        join(kb[v][j], suf[j]);
        up(kb[v][j]);
      }
      L (j, 1, K) {
        join(suf[j], ksub[v][j - 1]);
      }
    }
  }
}

void dfs4 (int u) {
  L (i, 0, K) {
    kup[u][i] = kup[fa[u]][i];
    join(kup[u][i], ksub[u][i]);
    up(kup[u][i]);
  }
  for (int v : g[u]) {
    dfs4(v);
  }
  L (i, 0, K) {
    L (j, 0, i) {
      join(fd[u][i], ksub[u][j]);
    }
    int t = u;
    L (j, 1, i) {
      L (k, 0, i - j) {
        join(fd[u][i], kb[t][k]);
      }
      if (!(t = fa[t])) {
        break;
      }
    }
    up(fd[u][i]);
  }
}

vp del (vp a, vp b) {
  sort(a.begin(), a.end());
  sort(b.begin(), b.end());
  vp c;
  int l = 0;
  for (auto &x : a) {
    while (l < sz(b) && b[l].second < x.first) {
      ++l;
    }
    int r = l;
    while (r < sz(b) && b[r].first <= x.second) {
      ++r;
    }
    if (l == r) {
      c.eb(x);
      continue;
    }
    int p = x.first;
    L (t, l, r - 1) {
      if (p < b[t].first) {
        c.eb(p, b[t].first - 1);
      }
      p = b[t].second + 1;
    }
    if (p <= x.second) {
      c.eb(p, x.second);
    }
    l = r;
  }
  up(c);
  return c;
}

vp get (int x, int y, int k) {
  int l = lca(x, y);
  vp a = del(kup[x][k], kup[l][k]);
  vp b = del(kup[y][k], kup[l][k]);
  vp c = fd[l][k];
  join(a, b);
  join(a, c);
  up(a);
  return a;
}

#define ls p << 1
#define rs p << 1 | 1
#define m ((l + r) >> 1)

struct SGT {
  LL s[N << 2], mx[N << 2], lz[N << 2];

  void mdy (int ql, int qr, int l, int r, int p, LL x) {
    if (ql <= l && r <= qr) {
      s[p] += (r - l + 1) * x;
      mx[p] += x;
      lz[p] += x;
      return;
    }
    if (ql <= m) {
      mdy(ql, qr, l, m, ls, x);
    }
    if (m < qr) {
      mdy(ql, qr, m + 1, r, rs, x);
    }
    s[p] = s[ls] + s[rs] + lz[p] * (r - l + 1);
    mx[p] = max(mx[ls], mx[rs]) + lz[p];
  }

  LL qsum (int ql, int qr, int l, int r, int p) {
    if (ql <= l && r <= qr) {
      return s[p];
    }
    LL s = 0;
    if (ql <= m) {
      s += qsum(ql, qr, l, m, ls);
    }
    if (m < qr) {
      s += qsum(ql, qr, m + 1, r, rs);
    }
    return s + lz[p] * (min(qr, r) - max(ql, l) + 1);
  }

  LL qmax (int ql, int qr, int l, int r, int p) {
    if (ql <= l && r <= qr) {
      return mx[p];
    }
    LL s = -9e18;
    if (ql <= m) {
      s = qmax(ql, qr, l, m, ls);
    }
    if (m < qr) {
      s = max(s, qmax(ql, qr, m + 1, r, rs));
    }
    return s + lz[p];
  }
} T;

#undef m

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  L (i, 1, n - 1) {
    int u, v;
    cin >> u >> v;
    g[u].eb(v);
    g[v].eb(u);
  }
  dfs1(1);
  L (i, 1, 17) {
    L (j, 1, n - (1 << i) + 1) {
      st[i][j] = cp(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
    }
  }
  dfs2(1);
  dfs3(1);
  dfs4(1);
  while (m--) {
    int o;
    cin >> o;
    if (o == 1) {
      int x, y, k, v;
      cin >> x >> y >> k >> v;
      vp a = get(x, y, k);
      for (auto &[l, r] : a) {
        T.mdy(l, r, 1, n, 1, v);
      }
    } else if (o == 2) {
      int x, v;
      cin >> x >> v;
      for (auto &[l, r] : sub[x]) {
        T.mdy(l, r, 1, n, 1, v);
      }
    } else if (o == 3) {
      int x, y, k;
      cin >> x >> y >> k;
      vp a = get(x, y, k);
      LL s = 0;
      for (auto &[l, r] : a) {
        s += T.qsum(l, r, 1, n, 1);
      }
      cout << s << '\n';
    } else if (o == 4) {
      int x;
      cin >> x;
      LL s = 0;
      for (auto &[l, r] : sub[x]) {
        s += T.qsum(l, r, 1, n, 1);
      }
      cout << s << '\n';
    } else if (o == 5) {
      int x, y, k;
      cin >> x >> y >> k;
      vp a = get(x, y, k);
      LL s = -9e18;
      for (auto &[l, r] : a) {
        s = max(s, T.qmax(l, r, 1, n, 1));
      }
      cout << s << '\n';
    } else {
      int x;
      cin >> x;
      LL s = -9e18;
      for (auto &[l, r] : sub[x]) {
        s = max(s, T.qmax(l, r, 1, n, 1));
      }
      cout << s << '\n';
    }
  }
}
// I love WHQ!