#include <iostream>
#include <math.h>
#include <tuple>
#include <set>
#include <assert.h>

using namespace std;

const int MAXN = 3e5 + 5;

double A, B, R;
int n;

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 <(const P &p) const {return tie(x, y) < tie(p.x , p.y); }
    bool operator ==(const P &p) const {return tie(x, y) == tie(p.x , p.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 dot(P p) const { return x * p.x + y * p.y; }
    T dist2() const  { return x * x + y * y; }
    T cross(P p) const { return x * p.y - y * p.x; }
    double dist() const { return sqrt((double)dist2());}
    P perp() const { return P(-y, x); }
    P unit() const { return *this/dist(); }
    friend ostream& operator <<(ostream &os, const P &p) {
        os << p.x << ' ' << p.y << '\n';
        return os;
    }
};

typedef Point<double> P;

struct Event {
    int v;
    P p;
    Event(P pp, int vv): p(pp), v(vv) {}
    bool operator <(const Event &e) const { return p < e.p || (p == e.p && v > e.v); }
};

pair<P, P> circleTangents(const P &p, const P &c, double r) {
    P a = p - c;
    double x = r * r / a.dist2(), y = sqrt(x - x * x);
    return make_pair(c + a * x + a.perp() * y, c + a * x - a.perp() * y);
}

double lineDist(const P &a, const P &b, const P &p) {
    return (double)abs((b - a).cross(p - a)) / (b - a).dist();
}

const double EPS = 1e-6;

int main()
{
    ios_base::sync_with_stdio(false); cin.tie(0);
    cin >> n >> R >> A >> B;
    P S;
    P E(1.0 * A, 1.0 * B);
    P V = (E - S).unit();
    P N =  V.perp();
    multiset<Event> events;
    for(int i = 0; i < n; ++i) {
        double x, y;
        cin >> x >> y;
        P O(x, y);
        auto dist = lineDist(S, E, O);
        if (dist < EPS) {
            // O lies on pier
            P O1 = O + V * R;
            P O2 = O - V * R;
//            cout << i << '\n';
//            cout << O1 << ' ' << O2 << '\n';
            if (O2 < O1)
                swap(O1, O2);
            events.insert({O1, 1});
            events.insert({O2, -1});
            continue;
        }
        if (abs(dist - R) < EPS) {
            P O1 = O + N * R;
            P O2 = O - N * R;
            if (lineDist(S, E, O2) < EPS)
                O1 = O2;
//            cout << "Case 1: " << i << ' ' << O1 << '\n';
            events.insert({O1, 1});
            events.insert({O1, -1});
            continue;
        }
        if (dist > R) continue;

        P O1 = O + N * dist;
        P O2 = O - N * dist;
        if (lineDist(S, E, O2) < EPS)
                O1 = O2;

//        cerr << lineDist(S, E, O1) << ' ' << lineDist(S, E, O2) << '\n';

        double dkm = sqrt(R * R - dist * dist);
        auto ans1 = O1 + V * dkm;
        auto ans2 = O1 - V * dkm;
        if (ans2 < ans1)
            swap(ans1, ans2);
        pair<P, P> ans = {ans1, ans2};

//        P T1 = O + N * 10 * R;
//        P T2 = O - N * 10 * R;
//        auto ans1 = circleTangents(T1, O, R);
//        auto ans2 = circleTangents(T2, O, R);
//        auto ans = ans1;
//        if (lineDist(S, E, ans1.first) > EPS)
//            ans = ans2;
//        if (ans.second < ans.first)
//            swap(ans.first, ans.second);
//
//        cerr << ans1.first << '\n';
//        cerr << ans1.second << '\n';
//        cerr << ans2.first << '\n';
//        cerr << ans2.second << '\n';
//        cerr << ans.first << '\n';
//        cerr << ans.second << '\n';

        assert(lineDist(S, E, ans.first) < EPS || lineDist(S, E, ans.second) < EPS);
        events.insert({ans.first, 1});
        events.insert({ans.second, -1});
    }

    int cur = 0;
    int res = 0;

    for(auto e: events) {
//        cout << e.p << ' ' << e.v << '\n';
        cur += e.v;
        res = max(res, cur);
    }

    cout << res << '\n';

    return 0;
}