import java.io.*;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.*;

public class Mark64 {

    static MathContext PRECISION_LEVEL = MathContext.DECIMAL64;

    static BigDecimal[] factorial;
    public static void initFactorial()
    {
        factorial = new BigDecimal[2001];
        factorial[0] = BigDecimal.ONE;
        for (int i = 1; i < 2001; ++i)
            factorial[i] = factorial[i-1].multiply(BigDecimal.valueOf(i), PRECISION_LEVEL);
    }

    public static void main(String[] args) throws IOException {
        FastReader fr = new FastReader();
        PrintWriter pw = new PrintWriter(System.out);

        int N = fr.nextInt(), K = fr.nextInt(), D = fr.nextInt();

        initFactorial();
        BigDecimal ans = BigDecimal.ZERO;
        BigDecimal totalWays = comb(N, K); // all unique ways to end with K points

        Point[] points = new Point[N];
        for (int i = 0; i < N; ++i)
            points[i] = new Point(Math.round(fr.nextDouble() * 100), Math.round(fr.nextDouble() * 100));

        for (int i = 0; i < N; ++i)
        {
            List<Line> lines = new ArrayList<>();
            for (int j = 0; j < N; ++j)
                if (j != i)
                    lines.add(new Line(points[i], points[j]));

            lines.sort(Line::compare);

            int above = 0;
            int below = 0;
            for (Line l : lines)
            {
                if (l.flip) below++;
                else above++;
            }

            for (int j = 0; j < lines.size(); )
            {
                Line l = lines.get(j);

                // =========================================
                // ==== IDENTIFY COLLINEAR =================
                // =========================================

                int numFlipped = 0, numNotFlipped = 0;
                if (l.flip) numFlipped++; else numNotFlipped++;
                int numMatches = 1;

                while (j + numMatches < lines.size() && l.dir.cross(lines.get(j + numMatches).dir) == 0)
                {
                    // collinear lines
                    int j2 = j + numMatches;
                    Line l2 = lines.get(j2);
                    numMatches++;
                    if (l2.flip) numFlipped++; else numNotFlipped++;
                }

                // =========================================
                // ==== MOVE THE LINE ======================
                // =========================================

                above -= numNotFlipped;
                below -= numFlipped;

                // =========================================
                // ==== DO THE MATH ========================
                // =========================================

                for (int k = 0; k < numFlipped; ++k)
                {
                    l = lines.get(j + k); // current line

                    int numCollinearToRemoved = numNotFlipped + k;

                    BigDecimal chance1 = numWaysToRemove(N, K, above + numCollinearToRemoved).divide(totalWays, PRECISION_LEVEL);
                    BigDecimal chance2 = numWaysToRemove(N, K, below + numCollinearToRemoved).divide(totalWays, PRECISION_LEVEL);
                    BigDecimal len = BigDecimal.valueOf(Math.sqrt(l.dir.magSquared()));
                    ans = ans.add(len.multiply(chance1.add(chance2)), PRECISION_LEVEL);
                }

                // =========================================
                // ==== MOVE THE LINE ONCE MORE ============
                // =========================================

                below += numNotFlipped;
                above += numFlipped;

                j += numMatches;
            }
        }

        ans = ans.divide(BigDecimal.valueOf(100), PRECISION_LEVEL);
        BigDecimal circumph = BigDecimal.valueOf(D).multiply(BigDecimal.valueOf(Math.PI));
        pw.println(ans.add(circumph));

        pw.close();
    }

    static BigDecimal numWaysToRemove(int N, int K, int numToRemove)
    {
        // for us to select this edge on the hull we must:
        // (a) NOT delete the two points on this line
        // (b) DO delete all points on one side of the line (or both)

        // N points, K points remaining
        // (N choose K) ways to select K points
        // If I need to delete A points, there are (N - 2 - A choose K - A) ways to do this

        return comb(N - 2 - numToRemove, N - K - numToRemove);
    }

    static BigDecimal comb(int N, int R)
    {
        if (N < 0 || R < 0 || R > N) return BigDecimal.ZERO;
        return factorial[N].divide(
                factorial[R].multiply(factorial[N-R], PRECISION_LEVEL)
        , PRECISION_LEVEL);
    }

    static class Point
    {
        long x, y;
        public Point(long x, long y)
        {
            this.x = x;
            this.y = y;
        }

        Point minus(Point other)
        {
            return new Point(x - other.x, y - other.y);
        }
        Point add(Point other)
        {
            return new Point(x + other.x, y + other.y);
        }
        Point mult(long s)
        {
            return new Point(s * x, s * y);
        }
        long dot(Point other)
        {
            return x * other.x + y * other.y;
        }
        long cross(Point other)
        {
            return x * other.y - y * other.x;
        }
        long magSquared()
        {
            return x * x + y * y;
        }
    }

    static class Line
    {
        Point dir;
        boolean flip;

        public Line(Point base, Point p)
        {
            if (p.y < base.y || (p.y == base.y && p.x < base.x))
            {
                p = p.minus(base);
                this.dir = p.mult(-1);
                this.flip = true;
            }
            else
            {
                p = p.minus(base);
                this.dir = p;
                this.flip = false;
            }
        }

        public static int compare(Line a, Line b)
        {
            long c = a.dir.cross(b.dir);

            if (c == 0)
            {
                // collinear
                if (a.flip && !b.flip)
                    return -1; // a comes first
                else if (b.flip && !a.flip)
                    return 1; // b comes first;
                else if ((a.dir.magSquared() < b.dir.magSquared()) ^ a.flip)
                    return -1; // a comes first
                else
                    return 1; // b comes first
            }

            if (c < 0)  return 1;  // a comes before b
            else        return -1; // a comes after a
        }
    }

    /*
     *  Fast Reader
     */

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            st = null;
            return str;
        }
    }
}