fun main() {
    val testCase = readln().toInt()
    for (case in 1 .. testCase) {
        val (n, m, q) = readln().split(' ').map(String::toInt)
        val buses = List(m){
            val (u, v, k) = readln().split(' ').map(String::toInt)
            Triple(u - 1, v - 1, k - 1)
        }
        val contests = List(q) {
            val (p, c) = readln().split(' ').map(String::toInt)
            p - 1 to c - 1
        }
        val result = solve(n, m, q, buses, contests)
        println("Case #$case: $result")
    }
}

class UnionFind(val size: Int) {
    private val vec = IntArray(size){-1}
    fun find(a: Int): Int {
        if (vec[a] < 0) return a
        vec[a] = find(vec[a])
        return vec[a]
    }
    fun same(a: Int, b: Int): Boolean {
        return find(a) == find(b)
    }
    fun unite(a: Int, b: Int) {
        val x = find(a)
        val y = find(b)
        if (x == y) return
        if (vec[x] < vec[y]) {
            vec[x] += vec[y]
            vec[y] = x
        }else {
            vec[y] += vec[x]
            vec[x] = y
        }
    }
    fun sizeOf(a: Int): Int {
        return -vec[find(a)]
    }
}
fun solve(n: Int, m: Int, q: Int, buses: List<Triple<Int, Int, Int>>, contests: List<Pair<Int, Int>>): Int {
    val kMax = 100
    val canBeOdd = BooleanArray(q){false}
    for (remove in 0 .. kMax) {
        val uft = UnionFind(n)
        for ((u, v, k) in buses) {
            if (k == remove) continue
            uft.unite(u, v)
        }
        val clubCount = Array(n){ mutableSetOf<Int>()}
        for ((u, v, k) in buses) {
            if (k == remove) continue
            clubCount[uft.find(u)].add(k)
        }
        for (i in 0 until q) {
            if (canBeOdd[i]) continue
            val (p, c) = contests[i]
            if (!uft.same(p, c)) continue
            canBeOdd[i] = clubCount[uft.find(p)].size % 2 == 1
        }
    }
    return canBeOdd.count { it }
}