import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Locale;
import java.util.StringTokenizer;

public class crimescene_ats_tl implements Runnable {
    StringTokenizer st;
    PrintWriter out;
    BufferedReader br;

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static void main(String[] args) {
        new crimescene_ats_tl().run();
    }

    public double dist(double x1, double y1, double x2, double y2) {
        double vx = x1 - x2;
        double vy = y1 - y2;
        if (Math.abs(vx) < 1e9 && Math.abs(vy) < 1e9) {
            return Math.sqrt(vx * vx + vy * vy);
        }
        double norm = vx;
        if (vx == 0 || Math.abs(vy) > Math.abs(vx)) {
            norm = vy;
        }
        vx /= norm;
        vy /= norm;
        double d = Math.sqrt(vx * vx + vy * vy);
        vx /= d;
        vy /= d;
        return Math.abs((y1 - y2) / vy);
    }

    private void solve() throws IOException {
        int n = nextInt();
        double l = nextLong();
        int k = nextInt();
        boolean[] missing = new boolean[n * 3];

        for (int i = 0; i < k; i++) {
            int val = nextInt() - 1;
            missing[val] = true;
            missing[val + n] = true;
            missing[val + n * 2] = true;
        }
        double[] x = new double[n];
        double[] y = new double[n];
        for (int i = 0; i < n; i++) {
            x[i] = nextLong();
            y[i] = nextLong();
        }
        double totalMissing = 0;
        double totalLength = 0;
        ArrayList<Double> lengths = new ArrayList<Double>();
        for (int j = 0; j < 3; j++) {
            for (int i = 0; i < n; i++) {
                lengths.add(dist(x[i], y[i], x[(i + 1) % n], y[(i + 1) % n]));
            }
        }
        for (int i = 0; i < n; i++) {
            totalLength += lengths.get(i);
            if (missing[i]) {
                totalMissing += lengths.get(i);
            }
        }
        if (totalLength <= l) {
            out.println(0);
            return;
        }
        double maxCovered = 0;
        for (int left = 0; left < n; left++) {
            double covered = 0;
            double between = 0;
            int right = left;
            while (between + lengths.get(right) < l) {
                between += lengths.get(right);
                if (missing[right]) {
                    covered += lengths.get(right);
                }
                right++;
            }
//            System.err.println("left " + left + " " + right + " " + covered + " " + maxCovered);
            if (missing[right]) {
                covered += Math.min(lengths.get(right), l - between);
//                System.err.println("ending " + covered + " " + maxCovered);
            }
            maxCovered = Math.max(maxCovered, covered);

        }
        for (int right = 2 * n; right < n * 3; right++) {
            double covered = 0;
            double between = 0;
            int left = right;
            while (between + lengths.get(left - 1) < l) {
                between += lengths.get(left - 1);
                if (missing[left - 1]) {
                    covered += lengths.get(left - 1);
                }
                left--;
            }
//            System.err.println("right " + left + " " + right + " " + covered + " " + maxCovered);

            if (missing[left - 1]) {
                covered += Math.min(lengths.get(left - 1), l - between);
//                System.err.println("ending " + covered + " " + maxCovered);
            }
            maxCovered = Math.max(maxCovered, covered);
        }
        out.printf("%.8f", totalMissing - maxCovered);
    }

    public void run() {
        try {
            Locale.setDefault(Locale.US);
            br = new BufferedReader(new FileReader("crimescene.in"));
            out = new PrintWriter("crimescene.out");

            solve();

            br.close();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}
