package main

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

const MaxN = 405
const MaxD = 405
const Inf = 1 << 30

var cc [MaxD][MaxN]int16
var dist [MaxD][MaxN][MaxN]int16

type Edge struct {
	u, v, w int
}

func find(parent []int, x int) int {
	if parent[x] != x {
		parent[x] = find(parent, parent[x])
	}
	return parent[x]
}

func union(parent, rank []int, x, y int) {
	px := find(parent, x)
	py := find(parent, y)
	if px == py {
		return
	}
	if rank[px] < rank[py] {
		parent[px] = py
	} else {
		parent[py] = px
		if rank[px] == rank[py] {
			rank[px]++
		}
	}
}

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

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

	for _ = range make([]int, t) {
		var n, m, q int
		fmt.Fscan(in, &n, &m, &q)

		edges := make([]Edge, m)
		weights := make([]int, 0, m)
		weightSet := make(map[int]bool)

		for i := 0; i < m; i++ {
			var u, v, w int
			fmt.Fscan(in, &u, &v, &w)
			edges[i] = Edge{u, v, w}
			if !weightSet[w] {
				weightSet[w] = true
				weights = append(weights, w)
			}
		}

		sort.Ints(weights)
		d := len(weights)

		for j := 0; j < d; j++ {
			X := weights[j]

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

			for _, e := range edges {
				if e.w <= X {
					union(parent, rank, e.u, e.v)
				}
			}

			idOf := make([]int, n+1)
			s := 0
			for v := 1; v <= n; v++ {
				r := find(parent, v)
				if idOf[r] == 0 {
					s++
					idOf[r] = s
				}
				cc[j][v] = int16(idOf[r])
			}

			adj := make([][]int, s+1)
			for _, e := range edges {
				if e.w > X {
					c1 := int(cc[j][e.u])
					c2 := int(cc[j][e.v])
					if c1 != c2 {
						adj[c1] = append(adj[c1], c2)
						adj[c2] = append(adj[c2], c1)
					}
				}
			}

			for start := 1; start <= s; start++ {
				dd := make([]int16, s+1)
				for i := range dd {
					dd[i] = -1
				}
				dd[start] = 0

				qe := make([]int, 0, s)
				qe = append(qe, start)
				for qi := 0; qi < len(qe); qi++ {
					u := qe[qi]
					for _, v := range adj[u] {
						if dd[v] == -1 {
							dd[v] = dd[u] + 1
							qe = append(qe, v)
						}
					}
				}

				for to := 1; to <= s; to++ {
					dist[j][start][to] = dd[to]
				}
			}
		}

		answers := make([]int, q)
		for i := 0; i < q; i++ {
			var a, b, k int
			fmt.Fscan(in, &a, &b, &k)

			l, r := 0, d-1
			for l < r {
				mid := (l + r) / 2
				ca := int(cc[mid][a])
				cb := int(cc[mid][b])
				dd := dist[mid][ca][cb]
				if dd <= int16(k-1) {
					r = mid
				} else {
					l = mid + 1
				}
			}
			answers[i] = weights[l]
		}

		for i, ans := range answers {
			if i > 0 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, ans)
		}
		fmt.Fprintln(out)
	}
}