n, m, q = gets.split.map(&:to_i)

prob = {}
(1..m).each do
    i, j = gets.split.map(&:to_i) 
    i, j = [i, j].sort
    prob[(i << 4) + j] = q / 100.0
end

def f(n, prob)
    return 1.0 if n == 1
    return 0.0 if disconnected?(n, prob)
    return 1.0 - prob.values[0] if n == 2

    key = prob.keys[0]
    i, j = key >> 4, key & 15

    ans = 0

    if prob[key] >= 1e-11
        new_prob = prob.dup
        new_prob.delete(key)
        ans += prob[key] * f(n, new_prob)
    end

    if 1.0 - prob[key] >= 1e-11
        new_prob = Hash.new(1.0)
        prob.each do |k, q|
            u, v = k >> 4, k & 15
            next if k == key
            u = j if k >> 4 == i
            v = j if k & 15 == i
            u, v = [u, v].sort
            new_prob[(u << 4) + v] *= prob[k]
        end
        ans += (1.0 - prob[key]) * f(n-1, new_prob)
    end
    ans
end

require 'set'
def disconnected?(n, prob)
    return true if n > prob.size + 1
    neighbour = {}
    prob.each_key do |key|
        i, j = key >> 4, key & 15
        (neighbour[i] ||= []) << j
        (neighbour[j] ||= []) << i
    end
    i = neighbour.keys.min
    reached = Set[i]
    queue = [i]
    until queue.empty?
        i = queue.shift
        neighbour[i].each do |j|
            next if reached.include?(j)
            reached << j
            queue << j
        end
    end
    reached.size != n
end

printf("%.12f\n", f(n, prob))

