package main

import (
	"io"
	"os"
	"sort"
	"strconv"
)

func nextInt(data []byte, idx *int) int {
	n := len(data)
	i := *idx
	for i < n {
		c := data[i]
		if c >= '0' && c <= '9' {
			break
		}
		i++
	}
	val := 0
	for i < n {
		c := data[i]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		i++
	}
	*idx = i
	return val
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	n := nextInt(data, &idx)
	m := nextInt(data, &idx)
	k := nextInt(data, &idx)

	adj := make([][]int, n+1)
	prev := make([]int, 1, 2*m+1)
	curr := make([]int, 1, 2*m+1)
	curr[0] = 1

	mul := n + 1
	pairID := make(map[int]int, 2*m+1)

	for i := 0; i < m; i++ {
		u := nextInt(data, &idx)
		v := nextInt(data, &idx)

		id := len(prev)
		prev = append(prev, u)
		curr = append(curr, v)
		adj[u] = append(adj[u], id)
		pairID[u*mul+v] = id

		id = len(prev)
		prev = append(prev, v)
		curr = append(curr, u)
		adj[v] = append(adj[v], id)
		pairID[v*mul+u] = id
	}

	forb := make([][]int, len(prev))
	for i := 0; i < k; i++ {
		a := nextInt(data, &idx)
		b := nextInt(data, &idx)
		c := nextInt(data, &idx)
		if id, ok := pairID[a*mul+b]; ok {
			forb[id] = append(forb[id], c)
		}
	}

	for i := 1; i < len(forb); i++ {
		if len(forb[i]) > 1 {
			sort.Ints(forb[i])
		}
	}

	parent := make([]int, len(prev))
	for i := range parent {
		parent[i] = -2
	}
	parent[0] = -1

	queue := make([]int, 1, len(prev))
	queue[0] = 0
	end := -1

	for head := 0; head < len(queue); head++ {
		s := queue[head]
		if curr[s] == n {
			end = s
			break
		}

		fl := forb[s]
		b := curr[s]

		if len(fl) == 0 {
			for _, nid := range adj[b] {
				if parent[nid] == -2 {
					parent[nid] = s
					queue = append(queue, nid)
				}
			}
		} else if len(fl) <= 8 {
			for _, nid := range adj[b] {
				c := curr[nid]
				blocked := false
				for _, x := range fl {
					if x == c {
						blocked = true
						break
					}
				}
				if blocked {
					continue
				}
				if parent[nid] == -2 {
					parent[nid] = s
					queue = append(queue, nid)
				}
			}
		} else {
			for _, nid := range adj[b] {
				c := curr[nid]
				l, r := 0, len(fl)
				for l < r {
					mid := (l + r) >> 1
					if fl[mid] < c {
						l = mid + 1
					} else {
						r = mid
					}
				}
				if l < len(fl) && fl[l] == c {
					continue
				}
				if parent[nid] == -2 {
					parent[nid] = s
					queue = append(queue, nid)
				}
			}
		}
	}

	if end == -1 {
		os.Stdout.Write([]byte("-1\n"))
		return
	}

	chain := make([]int, 0)
	for s := end; s != -1; s = parent[s] {
		chain = append(chain, s)
	}

	out := make([]byte, 0, len(chain)*8)
	out = strconv.AppendInt(out, int64(len(chain)-1), 10)
	out = append(out, '\n')
	for i := len(chain) - 1; i >= 0; i-- {
		if i != len(chain)-1 {
			out = append(out, ' ')
		}
		out = strconv.AppendInt(out, int64(curr[chain[i]]), 10)
	}
	out = append(out, '\n')
	os.Stdout.Write(out)
}