package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	var pos int
	readInt := func() int {
		for pos < len(buf) && (buf[pos] < '0' || buf[pos] > '9') {
			pos++
		}
		if pos >= len(buf) {
			return 0
		}
		res := 0
		for pos < len(buf) && buf[pos] >= '0' && buf[pos] <= '9' {
			res = res*10 + int(buf[pos]-'0')
			pos++
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}

	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)
	}

	depth := make([]int, n+1)
	up := make([][20]int, n+1)
	order := make([]int, 0, n)

	q := make([]int, 0, n)
	q = append(q, 1)
	depth[1] = 1
	up[1][0] = 0
	order = append(order, 1)

	for len(q) > 0 {
		u := q[0]
		q = q[1:]

		for i := 1; i < 20; i++ {
			up[u][i] = up[up[u][i-1]][i-1]
		}

		for _, v := range adj[u] {
			if v != up[u][0] {
				depth[v] = depth[u] + 1
				up[v][0] = u
				order = append(order, v)
				q = append(q, v)
			}
		}
	}

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

	getChild := func(x, l int) int {
		targetDepth := depth[l] + 1
		for i := 19; i >= 0; i-- {
			if depth[x]-(1<<i) >= targetDepth {
				x = up[x][i]
			}
		}
		return x
	}

	m := readInt()

	diff0 := make([]int, n+1)
	diff1 := make([]int, n+1)
	lcaPaths := make([]int, n+1)
	pairMap := make(map[uint64]int)

	for i := 0; i < m; i++ {
		x, y := readInt(), readInt()

		l := getLCA(x, y)

		diff0[x]++
		diff0[y]++
		diff0[l]--
		diff0[up[l][0]]--

		diff1[x]++
		diff1[y]++
		diff1[l] -= 2

		var cx, cy int
		if x != l {
			cx = getChild(x, l)
			lcaPaths[cx]++
		}
		if y != l {
			cy = getChild(y, l)
			lcaPaths[cy]++
		}

		if x != l && y != l {
			if cx > cy {
				cx, cy = cy, cx
			}
			key := (uint64(cx) << 32) | uint64(cy)
			pairMap[key]++
		}
	}

	var ans int64

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		p := up[u][0]

		if u != 1 {
			uVal := int64(diff1[u] - lcaPaths[u])
			ans += uVal * (uVal - 1) / 2

			p1 := int64(diff1[u])
			ans -= 2 * (p1 * (p1 - 1) / 2)

			diff0[p] += diff0[u]
			diff1[p] += diff1[u]
		}

		p0 := int64(diff0[u])
		ans += p0 * (p0 - 1) / 2
	}

	for _, count := range pairMap {
		ans += int64(count) * int64(count-1) / 2
	}

	fmt.Println(ans)
}