```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

type BIT struct {
	tree []int
}

func NewBIT(size int) *BIT {
	return &BIT{tree: make([]int, size+1)}
}

func (b *BIT) Add(idx, val int) {
	for ; idx < len(b.tree); idx += idx & -idx {
		b.tree[idx] += val
	}
}

func (b *BIT) Query(idx int) int {
	sum := 0
	for ; idx > 0; idx -= idx & -idx {
		sum += b.tree[idx]
	}
	return sum
}

func (b *BIT) AddRange(L, R, val int) {
	if L < 1 {
		L = 1
	}
	if R >= len(b.tree) {
		R = len(b.tree) - 1
	}
	if L > R {
		return
	}
	b.Add(L, val)
	b.Add(R+1, -val)
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)

	scanInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	q := scanInt()

	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := scanInt()
		v := scanInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	chains := 0
	chainID := make([]int, n+1)
	depth := make([]int, n+1)
	var chainLen []int

	for _, startNode := range adj[1] {
		chainLen = append(chainLen, 0)
		c := chains

		curr := startNode
		prev := 1
		d := 1

		for {
			chainID[curr] = c
			depth[curr] = d
			chainLen[c] = d

			next := -1
			for _, v := range adj[curr] {
				if v != prev {
					next = v
					break
				}
			}
			if next == -1 {
				break
			}
			prev = curr
			curr = next
			d++
		}
		chains++
	}

	globalBIT := NewBIT(n + 1)
	chainBITs := make([]*BIT, chains)
	for i := 0; i < chains; i++ {
		chainBITs[i] = NewBIT(chainLen[i] + 1)
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for i := 0; i < q; i++ {
		typeReq := scanInt()
		if typeReq == 0 {
			v := scanInt()
			x := scanInt()
			d := scanInt()

			if v == 1 {
				globalBIT.AddRange(1, d+1, x)
			} else {
				c := chainID[v]
				Dv := depth[v]
				chainBITs[c].AddRange(max(1, Dv-d), Dv+d, x)
				if Dv <= d {
					globalBIT.AddRange(1, d-Dv+1, x)
					chainBITs[c].AddRange(1, d-Dv, -x)
				}
			}
		} else {
			v := scanInt()
			if v == 1 {
				fmt.Fprintln(out, globalBIT.Query(1))
			} else {
				c := chainID[v]
				Dv := depth[v]
				ans := chainBITs[c].Query(Dv) + globalBIT.Query(Dv+1)
				fmt.Fprintln(out, ans)
			}
		}
	}
}
```