package main

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

var in []int
var out []int
var depth []int
var up [][]int
var fenwicks [21]*Fenwick
var timer int
var adj [][]int

type Fenwick struct {
	tree []int
}

func (f *Fenwick) add(i, delta int) {
	for ; i < len(f.tree); i += i & -i {
		f.tree[i] += delta
	}
}

func (f *Fenwick) query(i int) int {
	sum := 0
	for ; i > 0; i -= i & -i {
		sum += f.tree[i]
	}
	return sum
}

func (f *Fenwick) queryRange(l, r int) int {
	if l > r {
		return 0
	}
	return f.query(r) - f.query(l-1)
}

func add_diff(node, r, val int) {
	if node == 0 {
		return
	}
	fenwicks[r].add(in[node], val)
}

func get_ancestor(x, j int) int {
	for i := 0; i < 5; i++ {
		if (j>>i)&1 == 1 {
			x = up[x][i]
			if x == 0 {
				break
			}
		}
	}
	return x
}

func get_lca(u, v int) int {
	if depth[u] < depth[v] {
		u, v = v, u
	}
	diff := depth[u] - depth[v]
	for i := 0; i < 19; i++ {
		if (diff>>i)&1 == 1 {
			u = up[u][i]
		}
	}
	if u == v {
		return u
	}
	for i := 18; i >= 0; i-- {
		if up[u][i] != up[v][i] {
			u = up[u][i]
			v = up[v][i]
		}
	}
	return up[u][0]
}

type Frame struct {
	u, p, d, edgeIdx int
}

func build_tree(root, n int) {
	st := make([]Frame, 0, n)
	st = append(st, Frame{root, 0, 0, 0})

	for len(st) > 0 {
		idx := len(st) - 1
		u := st[idx].u
		p := st[idx].p
		d := st[idx].d
		e := st[idx].edgeIdx

		if e == 0 {
			timer++
			in[u] = timer
			depth[u] = d
			up[u][0] = p
			for i := 1; i < 19; i++ {
				if up[u][i-1] != 0 {
					up[u][i] = up[up[u][i-1]][i-1]
				}
			}
		}

		if e < len(adj[u]) {
			v := adj[u][e]
			st[idx].edgeIdx++
			if v != p {
				st = append(st, Frame{v, u, d+1, 0})
			}
		} else {
			out[u] = timer
			st = st[:idx]
		}
	}
}

func readInt(sc *bufio.Scanner) int {
	sc.Scan()
	res := 0
	b := sc.Bytes()
	for _, ch := range b {
		res = res*10 + int(ch-'0')
	}
	return res
}

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

	n := readInt(sc)

	in = make([]int, n+1)
	out = make([]int, n+1)
	depth = make([]int, n+1)
	up = make([][]int, n+1)
	for i := range up {
		up[i] = make([]int, 19)
	}
	adj = make([][]int, n+1)

	for i := 0; i <= 20; i++ {
		fenwicks[i] = &Fenwick{tree: make([]int, n+1)}
	}

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

	build_tree(1, n)

	m := readInt(sc)

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

	for i := 0; i < m; i++ {
		typ := readInt(sc)
		if typ == 1 {
			v := readInt(sc)
			ans := 0
			for j := 0; j <= 20; j++ {
				anc := get_ancestor(v, j)
				if anc == 0 {
					break
				}
				for radius := j; radius <= 20; radius++ {
					ans += fenwicks[radius].queryRange(in[anc], out[anc])
				}
			}
			fmt.Fprintln(writer, ans)
		} else {
			u := readInt(sc)
			v := readInt(sc)
			k := readInt(sc)
			d := readInt(sc)

			a := get_lca(u, v)

			add_diff(u, d, k)
			add_diff(v, d, k)
			add_diff(a, d, -k)
			p_a := up[a][0]
			if p_a != 0 {
				add_diff(p_a, d, -k)
			}

			if d >= 1 {
				if u != a {
					add_diff(u, d-1, -k)
					add_diff(a, d-1, k)
				}
				if v != a {
					add_diff(v, d-1, -k)
					add_diff(a, d-1, k)
				}
			}

			for j := 1; j <= d; j++ {
				p := get_ancestor(a, j)
				c := get_ancestor(a, j-1)

				if d-j >= 0 {
					if p != 0 {
						add_diff(p, d-j, k)
						p_p := up[p][0]
						if p_p != 0 {
							add_diff(p_p, d-j, -k)
						}
					}
				}
				if d-j-1 >= 0 {
					if c != 0 {
						add_diff(c, d-j-1, -k)
						if p != 0 {
							add_diff(p, d-j-1, k)
						}
					}
				}
			}
		}
	}
}