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

#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define TRACE(x) cerr << #x << " = " << x << endl
#define _ << " _ " <<

#define pb push_back
#define x first
#define y second

#define LT <
#define GT >

typedef long long ll;
typedef long double lf;

const double eps = 1e-9;
const double PI = acos(-1);

inline bool lt(double a, double b) { return a + eps < b; }
inline bool gt(double a, double b) { return lt(b, a); }
inline bool eq(double a, double b) { return !lt(a, b) && !lt(b, a); }

struct Pt {
  double x, y;
  
  Pt operator + (const Pt &b) { return {x + b.x, y + b.y}; }
  Pt operator - (const Pt &b) { return {x - b.x, y - b.y}; }
};

Pt operator * (Pt P, double k) { return {P.x * k, P.y * k}; }
Pt operator * (double k, Pt P) { return {P.x * k, P.y * k}; }

inline double norm(const Pt &a) { return sqrt(a.x * a.x + a.y * a.y); }
inline double dot(const Pt &a, const Pt &b) {
  return a.x * b.x + a.y * b.y;
}
inline double dist(Pt a, Pt b) {
  return norm(b - a);
}

const int MAXN = 300050;
const int MAXR = 1001000;

int n, r,  a, b;
double R;
Pt dir;

double oznaka(Pt P) {
  return dot(dir, P);
}

Pt preslikaj(Pt P) {
  return oznaka(P) * dir;
}

vector<double> calc(Pt P) {
  double oz = oznaka(P);
  Pt PC = preslikaj(P);
  double D = dist(P, PC);
  if (gt(D, R)) return {};
  if (eq(D, R)) return {oz};
  double pit = sqrt(R * R - D * D);
  return {oz - pit, oz + pit};
}

enum evtip {IN, OUT};
vector<pair<double, int>> events;

bool cmp(pair<double, int> a, pair<double, int> b) {
  if (!eq(a.first, b.first)) return lt(a.first, b.first);
  return a.second < b.second;
}

int main(void) {
  scanf("%d%d%d%d", &n, &r, &a, &b);
  R = (double)r;
  Pt ab = {(double)a, (double)b};  
  dir = 1.0 / norm(ab) * ab;

  REP(i, n) {
    Pt p;
    scanf("%lf%lf", &p.x, &p.y);
    vector<double> c = calc(p);
    if (c.size() == 1) {
      events.push_back({c[0], IN});
      events.push_back({c[0], OUT});
//      TRACE(i _ "in" _ c[0]);    
//      TRACE(i _ "out" _ c[0]);    
    } else if (c.size() == 2) {
      events.push_back({c[0], IN});
      events.push_back({c[1], OUT});
//      TRACE(i _ "in" _ c[0]);    
//      TRACE(i _ "out" _ c[1]);    
    }
  }

  sort(events.begin(), events.end(), cmp);
  int curr = 0;
  int ans = 0;
  for (auto it : events) {
    if (it.second == IN) curr++;
    else curr--;
    ans = max(ans, curr);
  }
 
  printf("%d\n", ans);

  return 0;
}