A little girl loves problems on trees very much. Here's one of them.

A tree is an undirected connected graph, not containing cycles. The degree of node x in the tree is the number of nodes y of the tree, such that each of them is connected with node x by some edge of the tree. 

Let's consider a tree that consists of n nodes. We'll consider the tree's nodes indexed from 1 to n. The cosidered tree has the following property: each node except for node number 1 has the degree of at most 2.

Initially, each node of the tree contains number 0. Your task is to quickly process the requests of two types:

  * Request of form: 0 v x d. In reply to the request you should add x to all numbers that are written in the nodes that are located at the distance of at most d from node v. The distance between two nodes is the number of edges on the shortest path between them. 
  * Request of form: 1 v. In reply to the request you should print the current number that is written in node v. 

Input

The first line contains integers n (2 ≤ n ≤ 105) and q (1 ≤ q ≤ 105) — the number of tree nodes and the number of requests, correspondingly.

Each of the next n - 1 lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that show that there is an edge between nodes ui and vi. Each edge's description occurs in the input exactly once. It is guaranteed that the given graph is a tree that has the property that is described in the statement.

Next q lines describe the requests.

  * The request to add has the following format: 0 v x d (1 ≤ v ≤ n, 1 ≤ x ≤ 104, 1 ≤ d < n). 
  * The request to print the node value has the following format: 1 v (1 ≤ v ≤ n). 



The numbers in the lines are separated by single spaces.

Output

For each request to print the node value print an integer — the reply to the request.

Examples

Input

3 6
1 2
1 3
0 3 1 2
0 2 3 1
0 1 5 2
1 1
1 2
1 3


Output

9
9
6


Input

6 11
1 2
2 5
5 4
1 6
1 3
0 3 1 3
0 3 4 5
0 2 1 4
0 1 5 5
0 4 6 2
1 1
1 2
1 3
1 4
1 5
1 6


Output

11
17
11
16
17
11
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma hdrstop
using namespace std;
inline void sIO() {}
inline void iIO() {
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
}
inline void fIO(string fn) {
  freopen((fn + ".in").c_str(), "r", stdin);
  freopen((fn + ".out").c_str(), "w", stdout);
}
inline void TM() {}
inline void swap(short& a, short& b) { b ^= a ^= b ^= a; }
inline void swap(int& a, int& b) { b ^= a ^= b ^= a; }
inline void swap(char& a, char& b) { b ^= a ^= b ^= a; }
inline void swap(long long& a, long long& b) { b ^= a ^= b ^= a; }
template <class T>
inline T abs(T x) {
  return x < 0 ? -x : x;
}
template <class T>
inline T sqr(T x) {
  return x * x;
}
template <class T>
inline T min(T& a, T& b) {
  return a < b ? a : b;
}
template <class T>
inline T max(T& a, T& b) {
  return a > b ? a : b;
}
template <class T>
inline T gcd(T a, T b) {
  if (a < b) swap(a, b);
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}
template <class T>
inline T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
template <class T>
inline bool isPrime(T n) {
  if (n < 2) return false;
  T kk = (T)sqrt(n + 0.);
  for (T i = 2; i <= kk; ++i)
    if (!(n % i)) return false;
  return true;
}
template <class T>
inline string toa(T x) {
  stringstream ss;
  ss << x;
  string ret;
  ss >> ret;
  return ret;
}
template <class T>
inline T ppow(T a, long long b) {
  T ret = 1;
  while (b) {
    if (b & 1) ret *= a;
    a *= a;
    b >>= 1;
  }
  return ret;
}
template <class T>
inline T ppow(T a, long long b, long long md) {
  T ret = 1;
  a %= md;
  while (b) {
    if (b & 1) ret = ret * a % md;
    a = a * a % md;
    b >>= 1;
  }
  return ret % md;
}
inline int toi(string s) {
  stringstream ss;
  ss << s;
  int ret;
  ss >> ret;
  return ret;
}
inline long long tol(string s) {
  stringstream ss;
  ss << s;
  long long ret;
  ss >> ret;
  return ret;
}
inline int Random() { return ((rand() << 16) | rand()); }
inline int Random(int l, int r) {
  if (l == r) return l;
  return Random() % (r - l) + l;
}
inline char upperCase(char ch) {
  return (ch >= 'a' && ch <= 'z') ? ch ^ 32 : ch;
}
inline char lowerCase(char ch) {
  return (ch >= 'A' && ch <= 'Z') ? ch ^ 32 : ch;
}
inline string upperCase(string s) {
  int ls = s.length();
  for (int i = 0; i < ls; ++i)
    if (s[i] >= 'a' && s[i] <= 'z') s[i] ^= 32;
  return s;
}
inline string lowerCase(string s) {
  int ls = s.length();
  for (int i = 0; i < ls; ++i)
    if (s[i] >= 'A' && s[i] <= 'Z') s[i] ^= 32;
  return s;
}
inline int dig(char ch) { return ch - 48; }
inline bool isAlpha(char ch) {
  return (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z');
}
inline bool isDigit(char ch) { return (ch >= '0' && ch <= '9'); }
inline bool isLowerCase(char ch) { return (ch >= 'a' && ch <= 'z'); }
inline bool isUpperCase(char ch) { return (ch >= 'A' && ch <= 'Z'); }
int __;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const int MD = 1000000007;
int n, m, x, y, num[111111][2], tt, cur, to, kk, siz[111111], curpath, type, v,
    curv, xx, mx, one;
vector<vector<int> > g, tree;
void renum(int v, int p) {
  int tt = (int)g[v].size(), to;
  num[v][0] = cur, num[v][1] = ++kk;
  for (int i = 0; i < tt; ++i) {
    if ((to = g[v][i]) == p) continue;
    renum(to, v);
  }
}
void update(int path, int v, int tl, int tr, int l, int r, int add) {
  if (l > r) return;
  if (tl == l && tr == r)
    tree[path][v] += add;
  else {
    int tm = (tl + tr) >> 1;
    update(path, v << 1, tl, tm, l, min(r, tm), add);
    update(path, (v << 1) + 1, tm + 1, tr, max(tm + 1, l), r, add);
  }
}
int get(int path, int v, int tl, int tr, int pos) {
  if (tl == tr) return tree[path][v];
  int tm = (tl + tr) >> 1;
  if (pos <= tm)
    return tree[path][v] + get(path, v << 1, tl, tm, pos);
  else
    return tree[path][v] + get(path, (v << 1) + 1, tm + 1, tr, pos);
}
int main() {
  sIO();
  scanf("%d%d", &n, &m);
  g.resize(n + 5);
  for (int i = 1; i < n; ++i) {
    scanf("%d%d", &x, &y);
    if (x > y) swap(x, y);
    g[x].push_back(y);
    if (x != 1) g[y].push_back(x);
  }
  tree.resize((tt = (int)g[1].size()) + 5), cur = mx = 0;
  for (int i = 0; i < tt; ++i) {
    kk = 0;
    renum(g[1][i], 1);
    tree[cur].resize(((siz[cur] = kk) << 2) + 5), ++cur, mx = max(mx, kk);
  }
  tree[cur].resize((mx << 2) + 5);
  for (int i = 0; i < m; ++i) {
    scanf("%d%d", &type, &v);
    curpath = num[v][0], curv = num[v][1];
    if (!type) {
      scanf("%d%d", &x, &y);
      if (v == 1) {
        update(cur, 1, 1, mx, 1, min(mx, y), x);
        one += x;
        continue;
      }
      update(curpath, 1, 1, siz[curpath], max(1, curv - y),
             min(siz[curpath], curv + y), x);
      if (curv < y) {
        xx = y - curv;
        update(cur, 1, 1, mx, 1, min(mx, xx), x);
        update(curpath, 1, 1, siz[curpath], 1, min(siz[curpath], xx), -x);
      }
      if (curv <= y) one += x;
    } else if (v == 1)
      printf("%d\n", one);
    else
      printf("%d\n",
             get(cur, 1, 1, mx, curv) + get(curpath, 1, 1, siz[curpath], curv));
  }
  return 0;
}
