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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.Arrays;



public class C {
	
	static class Scanner{
		BufferedReader br=null;
		StringTokenizer tk=null;
		public Scanner(){
			br=new BufferedReader(new InputStreamReader(System.in));
		}
		public String next() throws IOException{
			while(tk==null || !tk.hasMoreTokens())
				tk=new StringTokenizer(br.readLine());
			return tk.nextToken();
		}
		public int nextInt() throws NumberFormatException, IOException{
			return Integer.valueOf(next());
		}
		public double nextDouble() throws NumberFormatException, IOException{
			return Double.valueOf(next());
		}
	}

	static class Fenwick{
		long[] tree;
		public Fenwick(int tam){
			tree = new long[tam];
			Arrays.fill(tree,0);
		}
		long query(int a, int b){
		    	if (a == 0) {
			    	long sum = 0;
			    	for (; b >= 0; b = (b & (b + 1)) - 1)
			    		sum += tree[b];
			    	return sum;
		    	}
		    	else {
		    		return query(0, b) - query(0, a - 1);
		    	}
		}
		void increase(int k, int inc){
			for (; k < (int) tree.length; k |= k + 1)
				tree[k] += inc;
      		}
    	}

	static class Node{
		int id;
		ArrayList<Integer> v;
		int depth;
		int branch;
		public Node(int id){
			this.id = id;
			v = new ArrayList<Integer>();
		}
	}

	static Node[] array;
	
	public static void main(String args[]) throws NumberFormatException, IOException{
		Scanner sc=new Scanner();
		int N=sc.nextInt();
		int Q=sc.nextInt();
		array = new Node[N];
		for(int i = 0 ; i< N ; i++)
			array[i] = new Node(i);
		for(int i = 0; i < N - 1; i++){
			int a=sc.nextInt();
			int b=sc.nextInt();
			a--;b--;
			array[a].v.add(b);
			array[b].v.add(a);
		}
		Fenwick[] branches = new Fenwick[array[0].v.size()];
		for(int i = 0; i < array[0].v.size(); i++)
			branches[i] = getbranch(i);
		Fenwick all = new Fenwick(100010);
		for( int i = 0; i < Q; i++){
			int opcode = sc.nextInt();
			if (opcode == 0){
				int v = sc.nextInt();
				v--;
				int x = sc.nextInt();
				int d = sc.nextInt();
				int  tt = d - array[v].depth;
				if (tt >= 0){
					all.increase(0 , x);
					all.increase(tt + 1, -x);
					branches[array[v].branch].increase(tt + 1, x);
					branches[array[v].branch].increase(array[v].depth + d + 1, -x);
				}
				else{
					branches[array[v].branch].increase(array[v].depth - d, x);
					branches[array[v].branch].increase(array[v].depth + d + 1, -x);
				}
			}
			else{
				int v = sc.nextInt();
				v--;
				long ans = branches[array[v].branch].query(0, array[v].depth);
				ans+= all.query(0, array[v].depth);
				System.out.println(ans);
			}
		}
		
	}

	static Fenwick getbranch(int b){
		int before=0;
		int depth=0;
		int actual=array[0].v.get(b);
		while(true){
			depth++;
			array[actual].depth = depth;
			array[actual].branch = b;
			if (array[actual].v.size() == 1)
				break;
			int nactual = array[actual].v.get(0);
			if (nactual == before)
				nactual = array[actual].v.get(1);
			before = actual;
			actual = nactual;
		}
		return new Fenwick(depth + 5);
	}
}