class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self,x):
        route = []
        while(x >= 0):
            route.append(x)
            x = self.parents[x]
        p = route.pop()
        for ri in route:
            self.parents[ri] = p
        return p

    def size(self, x):
        return self.parents[ self.find(x) ] * -1

    def same(self, x, y):
        x_root = self.find(x)
        y_root = self.find(y)
        return (x_root == y_root)

    def union(self,x,y):
        x_root = self.find(x)
        y_root = self.find(y)
        if(x_root == y_root):
            return
        if( self.parents[x_root] > self.parents[y_root] ):
            x_root,y_root = y_root,x_root
        self.parents[x_root] += self.parents[y_root]
        self.parents[y_root] = x_root

    def members(self,x):
        root = self.find(x)
        res = [ i for i in range(self.n) if self.find(i) == root ]
        return res

    def roots(self):
        res = [ i for i in range(self.n) if self.parents[i] < 0]
        return res

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        res = dict()
        for r in self.roots():
            res[r] = [r]
        for i in range(self.n):
            if not i in res:
                res[self.find(i)].append(i)
        return res

def solve(n,m,q,uvk,pc):
    links = [[] for _ in range(n+1)]
    it = iter(uvk)
    clubs = set()
    for ui,vi,ki in zip(it,it,it):
        links[ui].append((vi,ki))
        links[vi].append((ui,ki))
        clubs.add(ki)
    
    # 連結&クラブ数チェック
    group = [-1] * (n+1)
    g_club = []
    g_num = 0
    for i in range(1,n+1):
        if group[i] != -1:
            continue
        group[i] = g_num

        club_i = set()
        stack = [i]
        while stack:
            x = stack.pop()
            for y,ki in links[x]:
                club_i.add(ki)
                if group[y] != -1:
                    continue
                group[y] = g_num
                stack.append(y)
        
        g_club.append(len(club_i))
        g_num += 1
    
    # print(group)
    # print(g_club)

    ufs = []
    for cl in clubs:
        ufs.append(UnionFind(n+1))
        it = iter(uvk)
        for ui,vi,ki in zip(it,it,it):
            if cl == ki:
                continue
            ufs[-1].union(ui,vi)
    
    ans = 0
    it = iter(pc)
    for pi,ci in zip(it,it):
        if group[pi] != group[ci]:
            continue
        g_num = group[pi]
        if g_club[g_num] % 2 ==1:
            ans += 1
            continue

        for uf in ufs:
            if uf.same(pi,ci):
                ans += 1
                break
    
    return ans

                

# import sys
# import os
# f = open('./input.txt', 'r')
# sys.stdin = f

import sys
read = sys.stdin.buffer.read

t,*data = map(int,read().split())

idx = 0
for i in range(1,t+1):
    n,m,q = data[idx:idx+3]
    idx += 3
    uvk = data[idx:idx+3*m]
    idx += 3*m
    pc = data[idx:idx+2*q]
    idx += 2*q
    res = solve(n,m,q,uvk,pc)
    print(f'Case #{i}: {res}')