#include <iostream>
#include <queue>
#include <map>
#include <cmath>
#include <complex>
#include <vector>
#include <cstdio>
using namespace std;

typedef complex<double> P;
typedef pair<double, pair<int, pair<int,int> > > QSTATE;

#define EPS 1e-10
#define INF 999999999

double InnerProduct(const P &a, const P &b) {
    return a.real() * b.real() + a.imag() * b.imag();
}
P Sub(const P &a, const P &b) {
    return P(a.real() - b.real(), a.imag() - b.imag());
}
double GetAngle(const P &a, const P &b) {
    return acos(InnerProduct(a, b) / (abs(a) * abs(b)));
}

QSTATE _make_state(double cost, int carrot, int curr, int prev) {
    return make_pair(-cost, make_pair(carrot, make_pair(curr,prev))); // ??????????????????-cost
}
double _get_cost(const QSTATE &s) { return -s.first; }
int _get_carrot(const QSTATE &s)  { return s.second.first; }
int _get_curr(const QSTATE &s)    { return s.second.second.first; }
int _get_prev(const QSTATE &s)    { return s.second.second.second; }

double dp[10001][21][21];
vector<int> edges[21][21]; // [?????¨??°][????????????] = ?¬?????§??????§???????????????????????????
double costs[21][21];

int main () {
    int n; cin >> n;
    double r, degree; cin >> r >> degree;

    double rad = degree * M_PI / 180.0;

    vector<P> points;
    for (int i=0; i<n; i++) {
        double x,y; cin >> x >> y;
        points.push_back( P(x,y) );
    }

    // ???????§????
    for (int i=0; i<n; i++) { // ?????¨??°
        for (int j=0; j<n; j++) { // ??????
            if (i == j) continue;
            for (int k=0; k<n; k++) { // ?¬??????????
                if (i == k || j == k) continue;

                if (GetAngle(Sub(points[i], points[j]), Sub(points[k], points[i])) <= rad) {
                    edges[i][j].push_back(k);
                }
            }
        }
    }
    /*
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            printf("edges[%d][%d] = ", i,j);
            for (int k=0; k<edges[i][j].size(); k++) {
                printf("%d ", edges[i][j][k]);
            }
            cout << endl;
        }
    }
    */

    // cost????¨????
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            if (i == j) {
                costs[i][j] = INF;
            } else {
                costs[i][j] = abs(Sub(points[i], points[j]));
            }
        }
    }

    // init
    for (int i=0; i<10001; i++) for (int j=0; j<n; j++) for (int k=0; k<n; k++) dp[i][j][k] = INF;

    // (cost, (????????????????????°, (?????¨??°,??????)))
    priority_queue<QSTATE> q;
    for (int i=1; i<n; i++) {
        if (costs[0][i] <= r) {
            dp[1][i][0] = costs[0][i];
            q.push( _make_state(costs[0][i], 1, i, 0));
        }
    }

    while (!q.empty()) {
        QSTATE s = q.top(); q.pop();
        double cost = _get_cost(s);
        int carrot = _get_carrot(s);
        int curr = _get_curr(s);
        int prev = _get_prev(s);

        if (dp[carrot][curr][prev] < cost) continue;

        for (int i=0; i<edges[curr][prev].size(); i++) {
            int t = edges[curr][prev][i];
            double next_cost = cost + costs[curr][t];
            if (next_cost <= r && next_cost < dp[carrot + 1][t][curr]) {
                dp[carrot + 1][t][curr] = next_cost;
                q.push( _make_state(next_cost, carrot + 1, t, curr) );
            }
        }
    }

    int ans = 0;
    for (int i=0; i<10001; i++) {
        for (int j=0; j<n; j++) {
            for (int k=0; k<n; k++) {
                if (dp[i][j][k] != INF) {
                    //printf("dp[%d][%d][%d] = %f\n", i,j,k,dp[i][j][k]);
                    ans = i;
                    break;
                }
            }
        }
    }

    cout << ans << endl;

    return 0;
}

Measured memory_bytes: 38132