package main

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

type Edge struct {
	to, idx int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}

	adj := make([][]Edge, n+1)
	for i := 0; i < n-1; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], Edge{v, i})
		adj[v] = append(adj[v], Edge{u, i})
	}

	var m int
	fmt.Fscan(in, &m)

	type Query struct {
		u, v, g int
	}
	queries := make([]Query, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &queries[i].u, &queries[i].v, &queries[i].g)
	}

	ans := make([]int, n-1)
	for i := 0; i < n-1; i++ {
		ans[i] = 1
	}

	parent := make([]int, n+1)
	parentEdge := make([]int, n+1)
	visited := make([]int, n+1)
	visitID := 0

	q := make([]int, n)

	for _, query := range queries {
		visitID++
		head, tail := 0, 0
		q[tail] = query.u
		tail++
		visited[query.u] = visitID

		for head < tail {
			u := q[head]
			head++
			if u == query.v {
				break
			}
			for _, edge := range adj[u] {
				if visited[edge.to] != visitID {
					visited[edge.to] = visitID
					parent[edge.to] = u
					parentEdge[edge.to] = edge.idx
					q[tail] = edge.to
					tail++
				}
			}
		}

		curr := query.v
		for curr != query.u {
			idx := parentEdge[curr]
			if query.g > ans[idx] {
				ans[idx] = query.g
			}
			curr = parent[curr]
		}
	}

	for _, query := range queries {
		visitID++
		head, tail := 0, 0
		q[tail] = query.u
		tail++
		visited[query.u] = visitID

		for head < tail {
			u := q[head]
			head++
			if u == query.v {
				break
			}
			for _, edge := range adj[u] {
				if visited[edge.to] != visitID {
					visited[edge.to] = visitID
					parent[edge.to] = u
					parentEdge[edge.to] = edge.idx
					q[tail] = edge.to
					tail++
				}
			}
		}

		curr := query.v
		minG := 1000000000
		for curr != query.u {
			idx := parentEdge[curr]
			if ans[idx] < minG {
				minG = ans[idx]
			}
			curr = parent[curr]
		}
		if minG != query.g {
			fmt.Fprintln(out, "-1")
			return
		}
	}

	for i := 0; i < n-1; i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, ans[i])
	}
	fmt.Fprintln(out)
}