#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
#define double ld

template<class T>
struct Point {
	typedef Point P;
	T x, y;
	explicit Point(T _x=0, T _y=0) : x(_x), y(_y) {}
	bool operator<(P p) const { 
	    if(half() == p.half()) {
	        if(cross(p) == 0)
	            return dist2() < p.dist2();
	        else
	            return cross(p) > 0;
	    }
	    else
	        return half() < p.half();
	}
	bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
	P operator-() const { return P(-x, -y); }
	P operator+(P p) const { return P(x+p.x, y+p.y); }
	P operator-(P p) const { return P(x-p.x, y-p.y); }
	P operator*(T d) const { return P(x*d, y*d); }
	P operator/(T d) const { return P(x/d, y/d); }
	T cross(P p) const { return x*p.y - y*p.x; } // + => p on right
	T cross(P a, P b) const { return (a-*this).cross(b-*this); }
	bool half() const { return y < 0 || (y == 0 && x < 0); }
	T dist2() const { return x*x + y*y; }
	double dist() const { return sqrt((double)dist2()); }
	friend ostream& operator<<(ostream& os, P p) {
		return os << "(" << p.x << "," << p.y << ")"; }
};

typedef Point<ll> P;

constexpr double PI = acos(-1);

int main() {
    vector<vector<double>> C(2001, vector<double>(2001));
    C[0][0] = 1;
    for(int a = 1; a < sz(C); a++) {
        C[a][0] = 1;
        for(int b = 1; b <= a; b++) {
            C[a][b] = C[a][b-1]*(a-b+1)/b;
        }
    }
    
    auto choose = [&](int a, int b) {
        if(a < 0 || b < 0 || a < b)
            return (double)0;
        return C[a][b];  
    };
    
	cin.tie(0)->sync_with_stdio(0);
	int n, k, d;
    cin >> n >> k >> d;
    vector<P> p(n);
    for(int i = 0; i < n; i++) {
        double vx, vy;
        cin >> vx >> vy;
        vx *= 100;
        vy *= 100;
        p[i].x = (ll)round(vx);
        p[i].y = (ll)round(vy);
    }
    
    double ans = 0;
    
    auto go = [&](int pivot) {
        map<pair<P, int>, vector<P>> events;
        int in = 0;
        for(int i = 0; i < n; i++) {
            if(i == pivot)
                continue;
            P me = p[i]-p[pivot];
            ll g = gcd(abs(me.x), abs(me.y));
            if(me.half())
                in++;
            P enter = me/g;
            P exit = -me/g;
            events[{enter, 1}].pb(me);
            events[{exit, -1}].pb(me);
        }
        for(auto& [e, v] : events) {
            auto [_, op] = e;
            if(op == -1)
                in -= sz(v);
            else {
                sort(all(v));
                for(P next : v) {
                    double len = next.dist()/100;
                    ans += len*choose(in, k-2);
                    in++;
                }
            }
        }
    };
    
    for(int i = 0; i < n; i++) {
        go(i);
    }
    cout << fixed << setprecision(20) << ans/choose(n, k)+d*PI << "\n";
}