#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <numeric>
#include <string>
#include <string.h>
#include <map>
#include <set>
#include <functional>
#include <complex>
#include <stack>
#include <tuple>
#include <array>
using namespace std;
#define rep(i,n) for (int i=0; i < (n); i++)


typedef long long int ll;
typedef double D;      // ??§?¨?????????????double???long double?????????
typedef complex<D> P;  // Point
typedef pair<P, P> L;  // Line
typedef vector<P> VP;


const int INF = (1<<30) - 1;
const D EPS = 1e-9;
const int MOD = 1000000007;

#define X real()
#define Y imag()
#define LE(n,m) ((n) < (m) + EPS)
#define GE(n,m) ((n) + EPS > (m))
#define EQ(n,m) (abs((n)-(m)) < EPS)

class Edge{
public:
    int to;
    double cost;
    Edge(int to, double cost): to(to), cost(cost){};
};

int N;
double R, T;

//g++ -std=c++0x -msse4.2 -O3
//#include <bits/stdc++.h>
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    //cout.precision(16);
    //cout.setf(ios::fixed);
    
    cin >> N;
    cin >> R >> T;
    T = T * M_PI / 180;
    
    vector<P> cities(N);
    for(int i=0; i<N; i++){
        double x, y; cin >> x >> y;
        cities[i] = P(x, y);
    }
    
    vector<vector<vector<Edge>>> G(N, vector<vector<Edge>>(N));
    for(int i=0; i<N; i++){
        for(int j=0; j<N; j++) if(i != j){
            for(int k=0; k<N; k++) if(j != k){
                double rad = abs(arg((cities[j]-cities[i])/(cities[k]-cities[j])));
                if(LE(rad, T)){
                    G[i][j].push_back(Edge(k, abs(cities[k]-cities[j])));
                }
            }
        }
    }
    
    //???????????????????????£?????? ??´????????? ????????? ???????°??????¢
    vector<vector<vector<double>>> dp(int(R+1), vector<vector<double>>(N, vector<double>(N, INF)));
    //dp[0][0][0] = 0;
    
    for(int i=1; i<N; i++)
        dp[1][0][i] = abs(cities[i]-cities[0]);
    
    for(int i=1; i<int(R); i++){
        for(int j=0; j<N; j++){
            for(int k=0; k<N; k++) if(j != k){
                for(auto edge: G[j][k]){
                    dp[i+1][k][edge.to] = min(dp[i+1][k][edge.to], dp[i][j][k]+edge.cost);
                }
            }
        }
    }
    
    for(int i=R; i>=0; i--){
        for(int j=0; j<N; j++){
            for(int k=0; k<N; k++){
                if(LE(dp[i][j][k], R)){
                    cout << i << endl;
                    return 0;
                }
            }
        }
    }
    cout << 0 << endl;
    
    return 0;
}