```go
package main

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

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

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

	type Edge struct {
		to int
		id int
	}
	adj := make([][]Edge, n+1)

	for i := 1; 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})
	}

	LOG := 20
	parent := make([][]int, LOG)
	for i := range parent {
		parent[i] = make([]int, n+1)
	}
	depth := make([]int, n+1)

	order := make([]int, 0, n)
	stack := []int{1}
	parent[0][1] = 0
	depth[1] = 0

	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for _, e := range adj[u] {
			if e.to != parent[0][u] {
				parent[0][e.to] = u
				depth[e.to] = depth[u] + 1
				stack = append(stack, e.to)
			}
		}
	}

	for j := 1; j < LOG; j++ {
		for i := 1; i <= n; i++ {
			p := parent[j-1][i]
			if p != 0 {
				parent[j][i] = parent[j-1][p]
			}
		}
	}

	lca := func(u, v int) int {
		if depth[u] < depth[v] {
			u, v = v, u
		}
		for i := LOG - 1; i >= 0; i-- {
			if depth[u]-(1<<i) >= depth[v] {
				u = parent[i][u]
			}
		}
		if u == v {
			return u
		}
		for i := LOG - 1; i >= 0; i-- {
			if parent[i][u] != parent[i][v] {
				u = parent[i][u]
				v = parent[i][v]
			}
		}
		return parent[0][u]
	}

	cnt := make([]int, n+1)

	var k int
	fmt.Fscan(in, &k)
	for i := 0; i < k; i++ {
		var a, b int
		fmt.Fscan(in, &a, &b)
		cnt[a]++
		cnt[b]++
		w := lca(a, b)
		cnt[w] -= 2
	}

	ans := make([]int, n)

	for i := n - 1; i >= 0; i-- {
		u := order[i]
		for _, e := range adj[u] {
			if e.to != parent[0][u] {
				ans[e.id] = cnt[e.to]
				cnt[u] += cnt[e.to]
			}
		}
	}

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