from functools import lru_cache
from sys import stdin, stdout

t = int(stdin.readline())
for case in range(1,t+1):
    s = f"Case #{case}:"
    w, e, c = map(int,stdin.readline().split())

    w_adj = {n:[] for n in range(w)}
    e_adj = {n:[] for n in range(e)}
    
    i = 1
    for u in map(int,stdin.readline().split()):
        w_adj[i-1].append(u-1)
        w_adj[u-1].append(i-1)
        i += 1
    i = 1
    for u in map(int,stdin.readline().split()):
        e_adj[i-1].append(u-1)
        e_adj[u-1].append(i-1)
        i += 1

    w_parent = [None for _ in range(w)]
    w_children = [[] for _ in range(w)]
    e_parent = [None for _ in range(e)]
    e_children = [[] for _ in range(e)]

    def w_dig(n):
        for m in w_adj[n]:
            if m != w_parent[n]:
                w_parent[m]=n
                w_children[n].append(m)
                to_w_dig.append(m)
    def e_dig(n):
        for m in e_adj[n]:
            if m != e_parent[n]:
                e_parent[m]=n
                e_children[n].append(m)
                to_e_dig.append(m)

    #dodge python recursion limits
    to_w_dig = [0]
    to_e_dig = [0]
    for n in to_w_dig:
        w_dig(n)
    for n in to_e_dig:
        e_dig(n)
    w_trav = to_w_dig
    e_trav = to_e_dig
        
    @lru_cache(maxsize=None)
    def w_total_children(n):
        return sum(1 + w_total_children(m) for m in w_children[n])
    @lru_cache(maxsize=None)
    def e_total_children(n):
        return sum(1 + e_total_children(m) for m in e_children[n])
    
    @lru_cache(maxsize=None)
    def w_depth(n):
        if w_parent[n] == None:
            return 0
        else:
            return 1 + w_depth(w_parent[n])
    @lru_cache(maxsize=None)
    def e_depth(n):
        if e_parent[n] == None:
            return 0
        else:
            return 1 + e_depth(e_parent[n])
        
    @lru_cache(maxsize=None)
    def w_sum_edges_below(n):
        return sum(1 + w_total_children(m) + w_sum_edges_below(m) for m in w_children[n])
    @lru_cache(maxsize=None)
    def e_sum_edges_below(n):
        return sum(1 + e_total_children(m) + e_sum_edges_below(m) for m in e_children[n])
    
    def w_total_parents(n):
        return w - w_total_children(n) - 1
    def e_total_parents(n):
        return e - e_total_children(n) - 1

    @lru_cache(maxsize=None)
    def w_sum_edges_above(n):
        if w_depth(n) == 0:
            return 0
        else:
            return w_total_parents(n) + w_sum_edges_below(w_parent[n]) - 1 - w_total_children(n) - w_sum_edges_below(n) + w_sum_edges_above(w_parent[n])
    @lru_cache(maxsize=None)
    def e_sum_edges_above(n):
        if e_depth(n) == 0:
            return 0
        else:
            return e_total_parents(n) + e_sum_edges_below(e_parent[n]) - 1 - e_total_children(n) - e_sum_edges_below(n) + e_sum_edges_above(e_parent[n])

    def w_sum_edges(n):
        return w_sum_edges_above(n) + w_sum_edges_below(n)
    def e_sum_edges(n):
        return e_sum_edges_above(n) + e_sum_edges_below(n)

    def total_crossing_edges(w_n,e_n):
        return w*e + w*e_sum_edges(e_n) + e*w_sum_edges(w_n)

    @lru_cache(maxsize=None)
    def w_below_total(n):
        return sum(
            (
                (w_total_children(n) - w_total_children(i) - 1) * 
                (w_sum_edges_below(i) + (w_total_children(i) + 1))
            ) + 
            (w_sum_edges_below(i) + w_total_children(i) + 1) + w_below_total(i)
            for i in w_children[n])
    @lru_cache(maxsize=None)
    def e_below_total(n):
        return sum(
            (
                (e_total_children(n) - e_total_children(i) - 1) * 
                (e_sum_edges_below(i) + (e_total_children(i) + 1))
            ) + 
            (e_sum_edges_below(i) + e_total_children(i) + 1) + e_below_total(i)
            for i in e_children[n])

    #dodge python recursion limits
    for n in reversed(w_trav):
        w_below_total(n)
    for n in reversed(e_trav):
        e_below_total(n)
    for n in w_trav:
        w_sum_edges_above(n)
    for n in e_trav:
        e_sum_edges_above(n) 
        

    w_total = w_below_total(0)
    e_total = e_below_total(0)

    def f(w_n,e_n):
        return 2*(total_crossing_edges(w_n,e_n) + w_total + e_total)/((w+e)*(w+e-1))

    results = []
    for _ in range(c):
        a, b = map(int,stdin.readline().split())
        result = f(a-1, b-1)
        results.append(f" {result}")
    s = s + ''.join(results) + '\n'
    stdout.write(s)