#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
#include<complex>

using namespace std;

#define ll long long
#define ld long double
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)

#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
typedef vector<vi> vvi;
typedef pair<pii,pii> data;

#define in(a,b,c,d) make_pair(pii(a,b),pii(c,d))

int gcd(int a, int b){
    if(b==0) return a;
    return gcd(b,a%b);
}
int lcm(int a, int b){
    return a/gcd(a,b)*b;
}


const double PI=acos(-1);
const double EPS=1e-5; //うまくいかなかったらゆるめる
typedef complex<double> P;
typedef vector<P> G;
#define shosu(x) fixed<<setprecision(x)
#define diff(P,i) (P[(i+1)%P.size()] - P[i])

struct L : public vector<P> {
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
  L(){;}
};
struct C {
  P c;double r;
  C(const P &c,double r):c(c),r(r){}
};

namespace std{//演算子の定義
  bool operator < (const P& a,const P& b) {
    return real(a)!= real(b) ? real(a) < real(b) : imag(a) < imag(b);
    //return imag(a) != imag(b) ? imag(a) < imag(b) : real(a) < real(b)
  }
  bool operator == (const P& a,const P& b) {
    return a.real()==b.real() && a.imag()==b.imag();
  }
}


void printP(const P &p){
  cout << shosu(10) << p.real() << " " << p.imag() << endl;
}

void printL(const L &l) {
  	cout << shosu(10) << l[0].real() << " " << l[0].imag() << " " << l[1].real() << " " << l[1].imag() << endl;
}

void printG(const G &g) {
  for(int i = 0; i < g.size(); i++){
    cout << shosu(10) << g[i].real() << " " << g[i].imag() << endl;
  }
}

double distancePP(const P &p, const P &q){ //2点間の距離
  return hypot(p.real()-q.real(), p.imag()-q.imag());
}

int n;
double r,si;
G g;

bool f(int i, int j, int k){
    double rad = abs(arg((g[i]-g[j])/(g[j]-g[k])));
    return rad < si + EPS;
}


P inP(){
  double x,y;
//  scanf("%lf,%lf", &x, &y);
  cin >> x >> y;
  P p(x,y);
  return p;
}

G inG(int n){
  G g(n);
  for(int i = 0; i < n; i++){
    g[i] = inP();
  }
  return g;
}

#define MAX 10005

double dist[20][20];
double memo[20][20][MAX] = {};

int ans = 0;
vector<vvi> v;


signed main(void) {
    cin >> n;
    cin >> r >> si;
    si *= acos(-1)/180;
    g = inG(n);
    v = vector<vvi> (n,vvi(n));
    rep(i,n)rep(j,n)if(i != j){
        rep(k,n)if(k != i && k != j){
            if(f(i,j,k))v[i][j].push_back(k);
        }
    }
    rep(i,n)rep(j,n)dist[i][j] = distancePP(g[i],g[j]);
    rep(i,n)rep(j,n)rep(k,MAX) memo[i][j][k] = INF;
    priority_queue<data> q;
    loop(i,1,n)if(dist[0][i] < r + EPS){
        memo[0][i][1] = dist[0][i];
        q.push(in(-dist[0][i],0,i,1));
    }
    int ans = 0;
    while(q.size()){
        data d = q.top();
        q.pop();
        int prev = d.first.second;
        int now = d.second.first;
        int num = d.second.second;
        if(memo[prev][now][num] < -d.first.first)continue;
        //cout << prev << " " << now << " " << num << endl;
        ans = max(ans, num);
        rep(i,v[prev][now].size()){
            int to = v[prev][now][i];
            double cost = memo[prev][now][num] + dist[now][to];
            if(memo[now][to][num+1] < cost + EPS)continue;
            if(cost > r + EPS)continue;
            memo[now][to][num+1] = min(memo[now][to][num+1], cost);
            q.push(in(-cost,now,to,num+1));
        }
    }
    cout << ans << endl;
}



Measured memory_bytes: 34972