```go
package main

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

var (
	scanner *bufio.Scanner
	writer  *bufio.Writer
	n       int
	adj     [][]int
	queries [][]Query
	ans     []int64
	bit     []int64
)

type Query struct {
	d, x int
}

func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 0, 1<<20)
	scanner.Buffer(buf, 64<<20)
	writer = bufio.NewWriter(os.Stdout)
}

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

func update(idx int, val int64) {
	for idx <= n {
		bit[idx] += val
		idx += idx & -idx
	}
}

func query(idx int) int64 {
	var sum int64
	for idx > 0 {
		sum += bit[idx]
		idx -= idx & -idx
	}
	return sum
}

func dfs(u, p, depth int) {
	for _, q := range queries[u] {
		lim := depth + q.d
		if lim > n {
			lim = n
		}
		update(lim, int64(q.x))
	}

	ans[u] = query(n) - query(depth-1)

	for _, v := range adj[u] {
		if v != p {
			dfs(v, u, depth+1)
		}
	}

	for _, q := range queries[u] {
		lim := depth + q.d
		if lim > n {
			lim = n
		}
		update(lim, -int64(q.x))
	}
}

func main() {
	defer writer.Flush()

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

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

	m := readInt()
	queries = make([][]Query, n+1)
	for i := 0; i < m; i++ {
		v, d, x := readInt(), readInt(), readInt()
		queries[v] = append(queries[v], Query{d, x})
	}

	ans = make([]int64, n+1)
	bit = make([]int64, n+1)

	dfs(1, 0, 1)

	for i := 1; i <= n; i++ {
		if i > 1 {
			writer.WriteByte(' ')
		}
		writer.WriteString(strconv.FormatInt(ans[i], 10))
	}
	writer.WriteByte('\n')
}
```