import heapq

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    idx = 0

    N = int(data[idx])
    M = int(data[idx+1])
    K = int(data[idx+2])
    idx +=3

    X = int(data[idx]) -1
    Y = int(data[idx+1]) -1
    idx +=2

    vertices = []
    for _ in range(N):
        p = int(data[idx])
        q = int(data[idx+1])
        vertices.append((p, q))
        idx +=2

    edges = [[] for _ in range(N)]
    for _ in range(M):
        P = int(data[idx])-1
        Q = int(data[idx+1])-1
        idx +=2
        x1, y1 = vertices[P]
        x2, y2 = vertices[Q]
        length = ((x1 - x2)**2 + (y1 - y2)**2) ** 0.5
        edges[P].append((Q, length))
        edges[Q].append((P, length))

    # Compute dist_to_Y using Dijkstra
    dist_to_Y = [float('inf')] * N
    dist_to_Y[Y] = 0.0
    heap = []
    heapq.heappush(heap, (0.0, Y))
    while heap:
        d, u = heapq.heappop(heap)
        if d > dist_to_Y[u]:
            continue
        for v, w in edges[u]:
            if dist_to_Y[v] > d + w:
                dist_to_Y[v] = d + w
                heapq.heappush(heap, (dist_to_Y[v], v))

    # Now, find the K smallest simple paths from X to Y
    results = []
    heap = []
    initial_visited = frozenset([X])
    heapq.heappush(heap, (0.0, X, initial_visited))

    while heap:
        current_length, current_vertex, visited = heapq.heappop(heap)
        if current_vertex == Y:
            if len(results) < K:
                results.append(current_length)
                results.sort()
            else:
                if current_length < results[-1]:
                    results.append(current_length)
                    results.sort()
                    if len(results) > K:
                        results.pop()
            if len(results) >= K and current_length >= results[K-1]:
                break
            continue

        if len(results) >= K:
            lower_bound = current_length + dist_to_Y[current_vertex]
            if lower_bound >= results[K-1]:
                continue

        for neighbor, length in edges[current_vertex]:
            if neighbor not in visited:
                new_length = current_length + length
                if len(results) >= K:
                    lower = new_length + dist_to_Y[neighbor]
                    if lower >= results[K-1]:
                        continue
                new_visited = set(visited)
                new_visited.add(neighbor)
                new_visited_frozen = frozenset(new_visited)
                heapq.heappush(heap, (new_length, neighbor, new_visited_frozen))

    # Prepare the output
    results.sort()
    for i in range(K):
        if i < len(results):
            print("{0:.6f}".format(results[i]))
        else:
            print(-1)
    print()

if __name__ == "__main__":
    main()