#include <iostream>
#include <cmath>
#include <vector>

using namespace std;

#define x first
#define y second

typedef pair<double, double> point;

struct line {
    double a, b, c;
};

struct vec {
    double X, Y;
    vec(double _X, double _Y) : X(_X), Y(_Y) {};
};

double dot(vec a, vec b) {
    return a.X * b.X + a.Y * b.Y;
}

double dist (point o1, point o2) {
    return hypot(o1.x - o2.x, o1.y - o2.y);
}

void pointsToLine(point p1, point p2, line& l) {

    if (fabs(p1.x - p2.x) < 0.00001) {
        l.a = 1.0;
        l.b = 0.0;
        l.c = -p1.x;
    } else {
        l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
        l.b = 1;
        l.c = -(double)(l.a * p1.x) - p1.y;
    }
}

double norm_sq(vec v) {
    return v.X * v.X + v.Y * v.Y;
}

vec toVec(point a, point b) {
    return vec(b.x - a.x, b.y - a.y);
}

vec scale(vec v, double s) {
    return vec(v.X * s, v.Y * s);
}

point translate(point p, vec v) {
    return point(p.x + v.X, p.y + v.Y);
}

double distToLine(point p, point a, point b, point& c) {
    vec ap = toVec(a, p), ab = toVec(a, b);
    double u = dot(ap, ab) / norm_sq(ab);

    c = translate(a, scale(ab, u));
    return dist(p, c);
}

double distToSegment(point p, point a, point b, point& c) {
    vec ap = toVec(a, p), ab = toVec(a, b);
    double u = dot(ap, ab) / norm_sq(ab);

    if (u > 1.0) {
        c = point(b.x, b.y);
        return dist(p, b);
    }


    if (u < 0.0) {
        c = point(a.x, a.y);
        return dist(p, a);
    }

    return distToLine(p, a, b, c);
}

int n, r, A, B;
point points_nearby[300000];
int nearby_counter = 0;
line LINE;

vector<vector<point>> pointsxd;

int main() {

    cin >> n >> r >> A >> B;
    pointsToLine({0, 0}, {A, B}, LINE);

    double X, Y;
    for (int i = 0; i < n; i++) {
        cin >> X >> Y;
        point c;
        //cout << distToSegment({X, Y}, {0, 0}, {A, B}, c) << endl;
        if (distToSegment({X, Y}, {0, 0}, {A, B}, c) <= r + 0.001)  {
            points_nearby[nearby_counter] = {X, Y};
            nearby_counter++;
//            cout << points_nearby[nearby_counter - 1].x << " " << points_nearby[nearby_counter - 1].y << endl;
        }
    }

    vector<point> PEPEP;
    pointsxd.push_back(PEPEP);

    for (int i = 0; i < nearby_counter; i++) {
    
        bool siker = false;

        for (int j = 0; j < pointsxd.size(); j++) {
            bool can_insert = true;

            for (int k = 0; k < pointsxd[j].size(); k++) {
                if (dist(points_nearby[i], pointsxd[j][k]) > 2 * r + 0.001) {
                    can_insert = false;
                    break;
                }
            }
            
            if (can_insert) {
                pointsxd[j].push_back(points_nearby[i]);
                siker = true;
            }

            if (!siker) {
                vector<point> PEPE;
                PEPE.push_back(points_nearby[i]);

                pointsxd.push_back(PEPE);
            }
        }
    }

    int maxi = 0;
/*
    for (auto i : pointsxd) {
        for (auto j : i) {
            cout << j.x << " " << j.y << "\t";
        }
        cout << endl ;
    }
*/
//    cout << nearby_counter << endl;
//    cout << pointsxd.size() << endl;
    for (int i = 0; i < pointsxd.size(); i++) {
        maxi = max(maxi, (int)pointsxd[i].size());
    }
    cout << maxi << endl;
}