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;

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);
    }
}

void solve() {
    auto G = new double[][][](N + 1, N + 1, N + 1);
    foreach (i; 0 .. N + 1) foreach (j; 0 .. N + 1) G[i][j][] = -1;
    foreach (j; 0 .. N) {
        foreach (k; 0 .. N) {
            if (j == k) continue;
            G[N][j][k] = distance(P[j], P[k]);
        }
    }
    foreach (i; 0 .. N) {
        foreach (j; 0 .. N) {
            foreach (k; 0 .. N) {
                if (i == j || j == k || k == i) continue;
                if (angle(P[i], P[j], P[k]) <= r + EPS) {
                    G[i][j][k] = distance(P[j], P[k]);
                }
            }
        }
    }
    struct S {
        int prev, cur, count;
        double r;
    }
    DList!S Q;
    Q.insert(S(N, 0, 0, 0));
    auto D = new double[int][][](N + 1, N + 1);
    D[N][0][0] = 0;
    int ans = 0;
    while (!Q.empty) {
        auto s = Q.front; Q.removeFront;
        //writeln(s);
        ans = max(ans, s.count);
        foreach (next; 0 .. N) {
            if (G[s.prev][s.cur][next] < 0) continue;
            auto nr = s.r + G[s.prev][s.cur][next];
            if (D[s.cur][next].get(s.count + 1, 1e10) + EPS > nr && r >= nr + EPS) {
                D[s.cur][next][s.count + 1] = nr;
                Q.insert(S(s.cur, next, s.count + 1, nr));
            }
        }
    }
    writeln(ans);
}

void main() {
    input; solve;
}