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

#pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")	 

// #define double long double
// #define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

#define EPS (1e-11)
#define equals(a,b) (fabs((a)-(b)) < EPS)
const double PI = asinl(1) * 2;

struct Point{
  double x,y;
  Point(){}
  Point(double x,double y) :x(x),y(y){}
  Point operator+(Point p) {return Point(x+p.x,y+p.y);}
  Point operator-(Point p) {return Point(x-p.x,y-p.y);}
  Point operator*(double k){return Point(x*k,y*k);}
  Point operator/(double k){return Point(x/k,y/k);}
  double norm(){return x*x+y*y;}
  double abs(){return sqrt(norm());}

  bool operator < (const Point &p) const{
    return x!=p.x?x<p.x:y<p.y;
    //grid-point only
    //return !equals(x,p.x)?x<p.x:!equals(y,p.y)?y<p.y:0;
  }

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

const double INF = 1e9;

int N;
double R, Th;

vector<Point> ps;
double dist[20][20][10001];

struct St {
  int pre, now, cnt;
  double cost;

  St(int pre, int now, int cnt, double cost):
    pre(pre), now(now), cnt(cnt), cost(cost) {}  

  bool operator<( const St& S ) const {
    return cost < S.cost;    
  }
  bool operator>( const St& S ) const {
    return cost > S.cost;    
  }  
};

double distPP(Point a, Point b) {
  return sqrt(pow(a.x-b.x, 2)+pow(a.y-b.y, 2));  
}

double calc_ang(double a1, double a2, double b1, double b2) {
  double cosT = (a1*b1+a2*b2) / (sqrt(a1*a1+a2*a2)*sqrt(b1*b1+b2*b2));
  if ( cosT > 1.0 ) cosT = 1.0;
  if ( cosT < -1.0 ) cosT = -1.0;
  return acosl(cosT) * 180.0 / PI;  
}

double distP[20][20];
double angP[20][20][20];

void solve() {  
  fill_n(**dist, 20*20*10001, INF);  
  priority_queue<St, vector<St>, greater<St> > Q;
  Q.push(St(0, 0, 0, 0));
  while ( !Q.empty() ) {
    St q = Q.top(); Q.pop();
    int pre = q.pre, now = q.now, cnt = q.cnt;
    double cost = q.cost;

    if ( dist[pre][now][cnt] < INF ) continue;
    dist[pre][now][cnt] = cost;

    if ( cost > R+EPS ) continue;    

    for ( int i = 0; i < N; i++ ) {    
      if ( i == now || pre == i ) continue;
      if ( dist[now][i][cnt+1] < INF ) continue;      
      double ang = 0;
      if ( pre != now ) {
	ang = angP[pre][now][i];	
      }
      if ( ang > Th ) continue;
      Q.push(St(now, i, cnt+1, cost+distP[i][now]));      
    }
  }
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  cin >> N;
  cin >> R >> Th;

  ps.resize(N);
  for ( int i = 0; i < N; i++ ) {
    cin >> ps[i].x >> ps[i].y;    
  }

  for ( int i = 0; i < N; i++ ) {
    for ( int j = 0; j < N; j++ ) {
      distP[i][j] = distPP(ps[i], ps[j]);      
    }
  }

  for ( int i = 0; i < N; i++ ) {
    for ( int j = 0; j < N; j++ ) {
      for ( int k = 0; k < N; k++ ) {
	angP[i][j][k] = calc_ang(ps[j].x-ps[i].x,
				 ps[j].y-ps[i].y,
				 ps[k].x-ps[j].x,
				 ps[k].y-ps[j].y);
      }
    }
  }

  solve();

  int ans = 0;
  for ( int i = 0; i < N; i++ ) {
    for ( int j = 0; j < N; j++ ) {
      for ( int k = 0; k < 10001; k++ ) {
	if ( dist[i][j][k] <= R+EPS ) ans = max(ans, k);
      }
    }
  }

  cout << ans << endl;
  
  return 0;
}



Measured memory_bytes: 35296