```go
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
	}
	k := readInt()
	m := readInt()

	dsu_mst := make([]int, n+1)
	for i := 1; i <= n; i++ {
		dsu_mst[i] = i
	}
	var find_mst func(int) int
	find_mst = func(i int) int {
		root := i
		for dsu_mst[root] != root {
			root = dsu_mst[root]
		}
		curr := i
		for curr != root {
			nxt := dsu_mst[curr]
			dsu_mst[curr] = root
			curr = nxt
		}
		return root
	}

	head := make([]int, n+1)
	for i := range head {
		head[i] = -1
	}
	type EdgeNode struct {
		to, id  int
		is_ours bool
		next    int
	}
	edges := make([]EdgeNode, 0, 2*n)

	addEdge := func(u, v, id int, is_ours bool) {
		edges = append(edges, EdgeNode{v, id, is_ours, head[u]})
		head[u] = len(edges) - 1
		edges = append(edges, EdgeNode{u, id, is_ours, head[v]})
		head[v] = len(edges) - 1
	}

	for i := 0; i < k; i++ {
		u := readInt()
		v := readInt()
		pu := find_mst(u)
		pv := find_mst(v)
		if pu != pv {
			dsu_mst[pu] = pv
		}
		addEdge(u, v, i, true)
	}

	type CompEdge struct {
		u, v, w int
	}
	non_essential := make([]CompEdge, 0, m)

	for i := 0; i < m; i++ {
		u := readInt()
		v := readInt()
		w := readInt()
		pu := find_mst(u)
		pv := find_mst(v)
		if pu != pv {
			dsu_mst[pu] = pv
			addEdge(u, v, i, false)
		} else {
			non_essential = append(non_essential, CompEdge{u, v, w})
		}
	}

	bfs_order := make([]int, 0, n)
	queue := make([]int, 0, n)
	queue = append(queue, 1)
	visited := make([]bool, n+1)
	visited[1] = true

	up := make([]int, n+1)
	depth := make([]int, n+1)
	edge_type := make([]int, n+1)
	edge_idx := make([]int, n+1)

	for len(queue) > 0 {
		curr := queue[0]
		queue = queue[1:]
		bfs_order = append(bfs_order, curr)

		for i := head[curr]; i != -1; i = edges[i].next {
			e := edges[i]
			if !visited[e.to] {
				visited[e.to] = true
				up[e.to] = curr
				depth[e.to] = depth[curr] + 1
				if e.is_ours {
					edge_type[e.to] = 1
				} else {
					edge_type[e.to] = 0
				}
				edge_idx[e.to] = e.id
				queue = append(queue, e.to)
			}
		}
	}

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

	var find_p func(int) int
	find_p = func(i int) int {
		root := i
		for parent_dsu[root] != root {
			root = parent_dsu[root]
		}
		curr := i
		for curr != root {
			nxt := parent_dsu[curr]
			parent_dsu[curr] = root
			curr = nxt
		}
		return root
	}

	for _, u := range bfs_order {
		if u != 1 {
			if edge_type[u] == 0 {
				parent_dsu[u] = find_p(up[u])
			}
		}
	}

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

	for _, e := range non_essential {
		u, v, w := e.u, e.v, e.w
		u = find_p(u)
		v = find_p(v)
		for u != v {
			if depth[u] < depth[v] {
				u, v = v, u
			}
			idx := edge_idx[u]
			if ans[idx] == -1 {
				ans[idx] = w
			}
			parent_dsu[u] = find_p(up[u])
			u = find_p(u)
		}
	}

	total := int64(0)
	for i := 0; i < k; i++ {
		if ans[i] == -1 {
			fmt.Println("-1")
			return
		}
		total += int64(ans[i])
	}
	fmt.Println(total)
}
```