2021-11-05

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;

public class Solution {

    public static void main(String[] args) throws IOException {
        for (int i = 0; i < MaxN; i++) {
            adj.add(new ArrayList<>());
        }
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        int T = nextInt();
        for (int tc = 1; tc <= T; tc++) {
            readCase();
            work();
            System.out.println("#" + tc + " " + ans1 + " " + ans2);
        }
    }

    static void work() throws IOException {
        Arrays.fill(outD, 0, N + 1, Integer.MAX_VALUE);
        for (int i = 1; i <= N; i++) {
            if (inD[i] == 0) {
                dfs(i, 0, 0);
            }
        }
        ans1 = 0;
        ans2 = 0;
        for (int i = 1; i <= Q; i++) {
            int a = nextInt();
            int b = nextInt();
            int ca = getLca(a, b);
            if (ca == 0) {
                ans2++;
            } else {
                ans1 += (sum[a] - sum[ca]) + (sum[b] - sum[ca]);
            }
        }
        Arrays.fill(inD, 0, N + 1, 0);
        Arrays.fill(sum, 0, N + 1, 0);
        for (int i = 0; i < 20; i++) {
            Arrays.fill(f[i], 0, N + 1, 0);
        }
    }

    static int getLca(int a, int b) {
        if (isContains(b, a)) return a;
        for (int i = 19; i >= 0; i--) {
            if (isContains(b, f[i][a])) continue;
            a = f[i][a];
        }
        return f[0][a];
    }

    static boolean isContains(int a, int b) {
        return inD[b] <= inD[a] && outD[b] >= outD[a];
    }

    static void dfs(int cur, int fa, int len) {
        f[0][cur] = fa;
        for (int i = 1; i < 20; i++) {
            f[i][cur] = f[i - 1][f[i - 1][cur]];
            if (f[i][cur] == 0) break;
        }
        sum[cur] = sum[fa] + len;
        inD[cur] = timer_seq++;
        for (int[] nx : adj.get(cur)) {
            if (fa == nx[0]) continue;
            dfs(nx[0], cur, nx[1]);
        }
        outD[cur] = timer_seq++;
    }

    static void readCase() throws IOException {
        N = nextInt();
        M = nextInt();
        Q = nextInt();
        for (int i = 1; i <= N; i++) {
            adj.get(i).clear();
        }
        for (int i = 1; i <= M; i++) {
            int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            adj.get(a).add(new int[]{b, c});
            adj.get(b).add(new int[]{a, c});
        }
    }

    static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    static StreamTokenizer in;
    static final int MaxN = 100003;
    static final int[] inD = new int[MaxN];
    static final int[] outD = new int[MaxN];
    static final int[][] f = new int[20][MaxN];
    static final long[] sum = new long[MaxN];
    static final ArrayList<ArrayList<int[]>> adj = new ArrayList<>();
    static int N, M, Q, timer_seq;
    static long ans1, ans2;
}