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*.
The first line contains integers *n* (2 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) and *q* (1 ≤ *q* ≤ 10<sup class="upper-index">5</sup>) — the number of tree nodes and the number of requests, correspondingly.

Each of the next *n*  -  1 lines contains two integers *u*<sub class="lower-index">*i*</sub> and *v*<sub class="lower-index">*i*</sub> (1 ≤ *u*<sub class="lower-index">*i*</sub>, *v*<sub class="lower-index">*i*</sub> ≤ *n*, *u*<sub class="lower-index">*i*</sub> ≠ *v*<sub class="lower-index">*i*</sub>), that show that there is an edge between nodes *u*<sub class="lower-index">*i*</sub> and *v*<sub class="lower-index">*i*</sub>. 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* ≤ 10<sup class="upper-index">4</sup>, 1 ≤ *d* &lt; *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.
from typing import List

g = []    # adjacency list representation of the graph
inTree = [0] * 100100   # keeps track of the subtree of each node
depth = [0] * 100100   # keeps track of the depth of each node
t = []   # 2D vector that represents the Fenwick tree

def dfs(v: int, d: int, num: int, p: int) -> None:
    inTree[v] = num
    depth[v] = d
    t[num].append(0)
 
    for i in range(len(g[v])):
        if g[v][i] == p:
            continue
        dfs(g[v][i], d + 1, num, v)

def add(p: int, v: int, num: int) -> None:
    for i in range(p, len(t[num]), i & (-i)):
        t[num][i] += v

def find(p: int, num: int) -> int:
    res = 0
    for i in range(p, 0, i & (-i)):
        res += t[num][i]
    return res

if __name__ == "__main__":
    n, q = map(int, input().split())
    g = [[] for _ in range(n)]
 
    for i in range(n - 1):
        x, y = map(int, input().split())
        x -= 1
        y -= 1
        g[x].append(y)
        g[y].append(x)
 
    t = [[] for _ in range(len(g[0]) + 1)]
 
    inRoot = 0
 
    for i in range(len(g[0])):
        t[i].append(0)
        dfs(g[0][i], 1, i, 0)
 
    t[len(t) - 1].extend([0] * (n + 10))
    for i in range(q):
        ty = int(input())
        if ty == 0:
            v, val, dist = map(int, input().split())
            v -= 1
            if v == 0:
                inRoot += val
                add(1, val, len(t) - 1)
                add(dist + 1, -val, len(t) - 1)
            else:
                if dist >= depth[v]:
                    left = dist - depth[v]
                    inRoot += val
                    add(1, val, len(t) - 1)
                    add(left + 1, -val, len(t) - 1)
                    add(left + 1, val, inTree[v])
                    add(depth[v] + dist + 1, -val, inTree[v])
                else:
                    add(depth[v] - dist, val, inTree[v])
                    add(depth[v] + dist + 1, -val, inTree[v])
        else:
            v = int(input()) - 1
            if v == 0:
                print(inRoot)
            else:
                res = find(depth[v], inTree[v]) + find(depth[v], len(t) - 1)
                print(res)

   	   	 	   			 	 	 	  				 		