```go
package main

import (
	"bufio"
	"os"
	"sort"
)

type Edge struct {
	to int
	w  int
}

const INF int32 = 2000000000

func nextInt(reader *bufio.Reader) int {
	res := 0
	var b byte
	var err error
	for {
		b, err = reader.ReadByte()
		if err != nil {
			return 0
		}
		if b >= '0' && b <= '9' {
			break
		}
	}
	for {
		res = res*10 + int(b-'0')
		b, err = reader.ReadByte()
		if err != nil || b < '0' || b > '9' {
			return res
		}
	}
}

func writeInt(writer *bufio.Writer, n int32) {
	if n == 0 {
		writer.WriteByte('0')
		return
	}
	var buf [12]byte
	i := 11
	for n > 0 {
		buf[i] = byte(n%10) + '0'
		n /= 10
		i--
	}
	writer.Write(buf[i+1:])
}

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

	t := nextInt(reader)
	if t == 0 {
		return
	}

	maxN := 405
	minW := make([]int32, maxN*maxN*maxN)
	deque := make([]int, 3000)
	dist := make([]int, maxN)
	expanded := make([]bool, maxN)

	for tc := 0; tc < t; tc++ {
		n := nextInt(reader)
		m := nextInt(reader)
		q := nextInt(reader)

		adj := make([][]Edge, n+1)
		weights := make([]int, 0, m)

		for i := 0; i < m; i++ {
			u := nextInt(reader)
			v := nextInt(reader)
			w := nextInt(reader)
			adj[u] = append(adj[u], Edge{v, w})
			adj[v] = append(adj[v], Edge{u, w})
			weights = append(weights, w)
		}

		sort.Ints(weights)
		uniqueW := make([]int, 0, m)
		for i, w := range weights {
			if i == 0 || w != weights[i-1] {
				uniqueW = append(uniqueW, w)
			}
		}

		for s := 1; s <= n; s++ {
			for t_node := 1; t_node <= n; t_node++ {
				base := s*maxN*maxN + t_node*maxN
				for d := 0; d <= n; d++ {
					minW[base+d] = INF
				}
			}
		}

		for _, W_i := range uniqueW {
			for s := 1; s <= n; s++ {
				for i := 1; i <= n; i++ {
					dist[i] = n
					expanded[i] = false
				}
				dist[s] = 0

				head, tail := 1500, 1500
				deque[tail] = s
				tail++

				for head < tail {
					u := deque[head]
					head++

					if expanded[u] {
						continue
					}
					expanded[u] = true

					for _, edge := range adj[u] {
						cost := 0
						if edge.w > W_i {
							cost = 1
						}
						if dist[u]+cost < dist[edge.to] {
							dist[edge.to] = dist[u] + cost
							if cost == 0 {
								head--
								deque[head] = edge.to
							} else {
								deque[tail] = edge.to
								tail++
							}
						}
					}
				}

				for t_node := 1; t_node <= n; t_node++ {
					d := dist[t_node]
					if d <= n {
						idx := s*maxN*maxN + t_node*maxN + d
						if minW[idx] == INF {
							minW[idx] = int32(W_i)
						}
					}
				}
			}
		}

		for s := 1; s <= n; s++ {
			for t_node := 1; t_node <= n; t_node++ {
				base := s*maxN*maxN + t_node*maxN
				for d := 1; d <= n; d++ {
					if minW[base+d-1] < minW[base+d] {
						minW[base+d] = minW[base+d-1]
					}
				}
			}
		}

		for i := 0; i < q; i++ {
			u := nextInt(reader)
			v := nextInt(reader)
			k := nextInt(reader)
			d := k - 1
			if d > n {
				d = n
			}
			ans := minW[u*maxN*maxN+v*maxN+d]
			if i > 0 {
				writer.WriteByte(' ')
			}
			writeInt(writer, ans)
		}
		writer.WriteByte('\n')
	}
}
```