#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;

template <class T, class U>
vector<T> make_v(U size, const T& init){ return vector<T>(static_cast<size_t>(size), init); }

template<class... Ts, class U>
auto make_v(U size, Ts... rest) { return vector<decltype(make_v(rest...))>(static_cast<size_t>(size), make_v(rest...)); }

template<class T> void chmin(T &a, const T &b){ a = (a < b ? a : b); }
template<class T> void chmax(T &a, const T &b){ a = (a > b ? a : b); }

using real = double;
static constexpr real EPS = 1e-10;
real pi = acos(-1);
struct Point {
    real x, y;
    Point& operator+=(const Point a) { x += a.x; y += a.y;  return *this; }
    Point& operator-=(const Point a) { x -= a.x; y -= a.y;  return *this; }
    Point& operator*=(const real k) { x *= k; y *= k;  return *this; }
    Point& operator/=(const real k) { x /= k; y /= k;  return *this; }
    Point operator+(const Point a) const {return Point(*this) += a; }
    Point operator-(const Point a) const {return Point(*this) -= a; }
    Point operator*(const real k) const {return Point(*this) *= k; }
    Point operator/(const real k) const {return Point(*this) /= k; }
    bool operator<(const Point &a) const { return (x != a.x ? x < a.x : y < a.y); }
    explicit Point(real a = 0, real b = 0) : x(a), y(b) {};
};

istream& operator>> (istream& s, Point& P){
    s >> P.x >> P.y;
    return s;
}

double arg(Point p){
    return atan2(p.y, p.x);
}

struct Segment {
    Point a, b;
    Segment(Point x, Point y) : a(x), b(y) {};
};


inline real dot(Point a, Point b){ return a.x*b.x + a.y*b.y; }
inline real cross(Point a, Point b){ return a.x*b.y - a.y*b.x; }
inline real abs(Point a){ return sqrt(dot(a, a)); }

using Polygon = vector<Point>;

Point polar(double r, double t){
    return Point(r*cos(t), r*sin(t));
}

real angle(Point A, Point B){
    return acos(dot(A, B)/abs(A)/abs(B));
}


int main() {
    int n; real r, t;
    cin >> n >> r >> t;
    t = t*pi/180;
    int x = (int)ceil(r)+2;
    auto dp = make_v(x+1, n, n, -MOD*1.0);
    auto ok = make_v(n, n, n, 0);
    auto dist = make_v(n, n, 0.0);
    int ans = 0;
    Polygon p(n);
    for(auto &&i : p) cin >> i;

    for (int i = 0; i < n; ++i) {
        dp[0][0][i] = r-abs(p[0]-p[i]);
        for (int j = 0; j < n; ++j) {
            if(i == j) continue;
            dist[i][j] = abs(p[i]-p[j]);
        }
    }
    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;
                ok[i][j][k] = (abs(angle(p[k]-p[j], p[j]-p[i])) < t);
            }
        }
    }

    for (int i = 0; i < x; ++i) {
        int cont = 0;
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                if(j == k) continue;
                if(dp[i][j][k] > 0) ans = max(ans, i+1);
                for (int l = 0; l < n; ++l) {
                    if(k == l || j == l) continue;
                    if(ok[j][k][l] &&  dp[i][j][k] > dist[k][l]){
                        dp[i+1][k][l] = max(dp[i+1][k][l], dp[i][j][k]-dist[k][l]);
                        cont = 1;
                    }
                }
            }
        }
        if(!cont) break;
    }

    cout << ans << "\n";
    return 0;
}


Measured memory_bytes: 42312