#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <sstream>

using namespace std;

const double pi = acos(-1.0);
const double EPS = 1e-9;
const double INF = 1e50;

int cmp(double a, double b){ return fabs(a-b) < EPS ? 0 : ( a > b ? 1 : -1 ); }

//estrutura que representa um ponto
// ou um vetor dependendo da necessidade
struct pt{
    double x, y;

    pt(double x = 0.0, double y = 0.0) : x(x), y(y) {}
    double length() { return sqrt(x*x + y*y); }

    bool normalize(){
        double l = length();
        if(fabs(l) < EPS) //vetor nulo
            return false;

        x /= l; y /= l;
        return true;
    }

    pt operator - (pt p){
        return pt(x - p.x, y - p.y);
    }
    pt operator + (pt p){
        return pt(x + p.x, y + p.y);
    }
    pt operator * (double k){
        return pt(x * k, y * k);
    }
    pt operator / (double k){
        return pt(x / k, y / k);
    }

    bool operator < (const pt& p) const{
        if(fabs( x - p.x ) >= EPS) return x < p.x;
        return y < p.y;
    }

    bool operator == (const pt p){
        return ( fabs(x - p.x) < EPS && fabs(y - p.y) < EPS );
    }
};

double dist(pt a, pt b){
    return (a - b).length();
}

////////////////////////////////////////////////////

double dot(pt a, pt b){
    return a.x*b.x + a.y*b.y;
}

double cross(pt a, pt b){
    return a.x*b.y - a.y*b.x;
}

//////////////////////////////////////////////////////

//testa se c esta na caixa limitada por a e b
bool in_box(pt a, pt b, pt c){
    return (c.x >= min(a.x, b.x)-EPS) && (c.x <= max(a.x, b.x)+EPS)
        && (c.y >= min(a.y, b.y)-EPS) && (c.y <= max(a.y, b.y)+EPS);
}

double signed_area(pt& a, pt& b, pt& c){
    return cross((b-c),(a-c))/2.0;
}

//interseccao entre as retas a->b e c->d e guarda em inter
//retorna falso se sao paralelas
//retorna (INF, INF) se sao coincidentes
bool intersect(pt a, pt b, pt c, pt d, pt& inter){
    double det = cross(b-a, d-c);
    if(fabs(det) < EPS){
        if( fabs(signed_area(a, b, c)) < EPS){
            inter = pt(INF, INF);
            return true; //retas coincidentes
        }
        return false; //retas paralelas
    }
    double ua = ( cross(d-c, a-c) )/det; //parametros das retas
    //double ub = ( cross(b-a, a-c) )/det;
    inter = a + (b-a)*ua;
    return true;
}

//testa se exsite interseccao entre os dois segmentos
//retorna falso se nao ha intersecao
//retorna (INF, INF) se os segmentos sao sobrepostos
bool intersect_seg(pt a, pt b, pt c, pt d, pt& inter){
    if( !intersect(a, b, c, d, inter) ) return false;

    if( inter.x == INF && inter.y == INF )
        return in_box(a, b, min(c, d)) || in_box(c, d, min(a, b)); //segmentos sobrepostos

    return in_box(a, b, inter) && in_box(c, d, inter); //segmentos concorrentes
}

//a->b para a->c
double angle(pt a, pt b, pt c){
    pt va = b-a, v = c-a;
    va.normalize();
    pt vb(-va.y, va.x);
    return abs( atan2( dot(v, vb), dot(v, va) ) );
    //retirar abs() para obter angulo orientado
}

//determina o ponto mais proximo de c
//na reta ab
pt closest_point(pt a, pt b, pt c){
    //se colinares
    if( fabs( signed_area(a, b, c) ) < EPS) return c;

    pt v = b-a; v.normalize(); //ortogonal a ab
    double pr = dot( v, c-a );
    return ( a + (v*pr) );
}

//determina o ponto mais proximo de c
//no segmento ab
pt closest_point_seg(pt a, pt b, pt c){
    pt close = closest_point(a, b, c);
    if( in_box(a, b, close) ) return close;
    return dist(a, c) < dist(b, c) ? a : b;
}

int main(){
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(5);
    double n, m, a;
    double x, y;
    pt pts[4], p;

    while(cin >> n >> a && fabs(n) > EPS){
        m = 0;
        pts[0] = pt(0, 0);
        pts[1] = pt(0, a);
        pts[2] = pt(a, 0);
        pts[3] = pt(a, a);

        for(int i = 0; i < n; i++){
            cin >> x >> y;
            p = pt(x, y);

            if( cmp(dist(pts[0], p), a) <= 0 &&
                cmp(dist(pts[1], p), a) <= 0 &&
                cmp(dist(pts[2], p), a) <= 0 &&
                cmp(dist(pts[3], p), a) <= 0  )
                m++;
        }

        cout << fixed << setprecision(5) << m*a*a/n << "\n";
    }
    return 0;
}