import std.stdio;
import std.ascii;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
import std.c.string;
import std.random;
import std.regex;
import std.typecons;

const EPS = 1e-6;
struct Point {
    double x, y;
    Point opBinary(alias op)(in Point p) const {
        if (op == "+") return Point(x + p.x, y + p.y);
        if (op == "-") return Point(x - p.x, y - p.y);
    }
    Point opBinary(alias op)(double n) const {
        if (op == "*") return Point(n * x, n * y);
        if (op == "/") return Point(n / x, n / y);
    }
}
bool EQ(in Point a, in Point b) {
    return abs(a.x - b.x) <= EPS && abs(a.y - b.y) <= EPS;
}
double norm(in Point a) {
    return sqrt(a.x * a.x + a.y * a.y);
}
Point unit(in Point a) {
    return a / norm(a);
}
double distance(in Point a, in Point b) {
    auto dx = a.x - b.x,
         dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}
double dot(in Point a, in Point b) {
    return a.x * b.x + a.y * b.y;
}
double cross(in Point a, in Point b) {
    return a.x * b.y - a.y * b.x;
}
double angle(in Point a, in Point b, in Point c) {
    auto p = b - a, q = c - b;
    return acos(p.dot(q) / (p.norm * q.norm)) / PI * 180;
}

int N;
double r, theta;
Point[] P;
bool[][][] C;

void input() {
    scanf("%d\n", &N);
    scanf("%lf %lf\n", &r, &theta);
    P = new Point[N];
    foreach (i; 0 .. N) {
        int x, y; scanf("%d %d\n", &x, &y);
        P[i] = Point(x, y);
    }
    C = new bool[][][](N, N, N);
    foreach (i; 0 .. N) {
        foreach (j; 0 .. N) {
            foreach (k; 0 .. N) {
                if (i == j || j == k || k == i) continue;
                C[i][j][k] = angle(P[i], P[j], P[k]) < theta + EPS;
            }
        }
    }
    foreach (k; 1 .. N) C[0][0][k] = true;
}

const INF = 1e10;

void solve() {
    auto L = cast(int)(r) + 1;
    auto dp = new double[][][](N, N, L);
    foreach (i; 0 .. N) foreach (j; 0 .. N) dp[i][j][] = INF;
    dp[0][0][0] = 0.0;
    foreach (c; 0 .. L - 1) {
        foreach (u; 0 .. N) {
            foreach (v; 0 .. N) {
                foreach (n; 0 .. N) {
                    if (u == n || v == n) continue;
                    if (!C[u][v][n]) continue;
                    dp[v][n][c + 1] = min(dp[v][n][c + 1], dp[u][v][c] + distance(P[v], P[n]));
                }
            }
        }
    }
    foreach (l; 1 .. L) {
        foreach (i; 0 .. N) {
            foreach (j; 0 .. N) {
                if (dp[i][j][l] < r + EPS) {
                    //writeln([i, j, l], dp[i][j][l]);
                    goto next;
                }
            }
        }
        writeln(l - 1);
        break;
next:;
    }
}

void main() {
    input; solve;
}