def LabelInward(T, Counts, TD, v, incoming):
    nbrs = [n for n in T[v] if n != incoming]
    for n in nbrs:
        LabelInward(T, Counts, TD, n, v)
    if incoming is not None:
        Counts[incoming, v] = sum(Counts[v, n] for n in nbrs) + 1
        Counts[v, incoming] = len(T) - Counts[incoming, v]
        TD[v, incoming] = sum(TD[n, v] for n in nbrs)+Counts[incoming, v]

def LabelOutward(T, Counts, TD, DD, v, incoming):
    nbrs = [n for n in T[v] if n != incoming]
    if incoming is None: DD[v] = sum(TD[n,v] for n in nbrs)
    for n in nbrs:
        DD[n] = DD[v] + len(T) - 2*Counts[v, n]
        LabelOutward(T, Counts, TD, DD, n, v)

def Tree(L):
    T = {n:[] for pair in L for n in pair}
    for (a,b) in L:
        T[a].append(b)
        T[b].append(a)
    return T

def Label(T):
    TD = {(i,j):0 for i in T for j in T[i]}
    DD = {i:0 for i in T}
    Counts = {(i,j):0 for i in T for j in T[i]}

    v = 1
    LabelInward(T, Counts, TD, v, None)
    LabelOutward(T, Counts, TD, DD, v, None)
    return Counts, DD

try:
    T = int(input())
    for case in range(1,T+1):
        W, E, C = [int(x) for x in input().split(" ")]
        WL = []
        EL = []
        CL = []
        WL = [(i+1,x) for (i,x) in enumerate([int(x) for x in input().split(" ")])]
        EL = [(i+1,x) for (i,x) in enumerate([int(x) for x in input().split(" ")])]
        for i in range(C):
            CL.append([int(x) for x in input().split(" ")])
        WT = Tree(WL)
        ET = Tree(EL)
        WCounts, WD = Label(WT)
        ECounts, ED = Label(ET)
        outputs = []
        west = sum(WD.values())/2
        east = sum(ED.values())/2
        edges = (W+E)*(W+E-1)/2
        for (i,j) in CL:
            cross = WD[i]*E + ED[j]*W + E*W
            #print(cross, west, east, WD[i], ED[j], edges)
            outputs.append((cross + west + east)/edges)
        print(f"Case #{case}: {' '.join(map(str,outputs))}")
except ValueError:
    while 1: pass
except Exception:
    L = [1]*100000000000