import std.typecons;
import std.range;
import std.algorithm;
import std.array;
import std.complex;
import std.math;
import std.stdio;
import std.string;
import std.conv;
import core.memory;

int N;
real R, TH;
int[2][] cities;


struct State
{
    int lastCity;
    int nowCity;
    long cnt;
    real total;
    bool end = false;
}


struct AllState
{
    long maxCNT = 0;
    State[][Tuple!(int, int)] states;


    void add(State[] state)
    {
        foreach(e; state){
            if(e.end){
                maxCNT = max(maxCNT, e.cnt);
                continue;
            }

            auto lastNow = tuple(e.lastCity, e.nowCity);
            if(auto p = lastNow in states){
                foreach(ref s; *p)
                    if(s.cnt <= e.cnt && s.total >= e.total)
                        s.lastCity = -1;    // ????????????????????°

                states[lastNow] = states[lastNow].remove!"a.lastCity == -1"();
            }

            states[lastNow] ~= e;
        }
    }
}


void main()
{
    N = readln().chomp().to!uint;
    real[] RTH = readln().chomp().split(' ').map!(to!real).array;
    R = RTH[0];
    TH = RTH[1];

    foreach(i; 0 .. N){
        auto xy = readln().chomp().split(' ').map!(to!int).array;
        cities ~= [xy[0], xy[1]];
    }

    AllState allState;
    State[] states = [State(-1, 0, 0, 0, false)];
    size_t cnt;
    while(states.length){
        State[] next;
        foreach(e; states)
            next ~= getNext(e);
        allState.add(next);
        states.length = 0;
        foreach(k, v; allState.states)
            states ~= v;
        allState.states = null;
        //writeln(states);
        ++cnt;
        GC.collect();
        GC.minimize();
        //if(cnt > 2) break;
    }

    writeln(allState.maxCNT);
}


State[] getNext(State state)
{
    if(state.end) return [state];

    State[] dst;
    foreach(i; 0 .. N){
        //writeln(state);
        //writefln("%s, %s, %s", state.lastCity, state.nowCity, i);
        //writeln(getTheta(state.lastCity, state.nowCity, i));
        //writeln(getDistance(i, state.nowCity) + state.total);

        if(i != state.lastCity
        && i != state.nowCity
        && getTheta(state.lastCity, state.nowCity, i) < TH
        && getDistance(i, state.nowCity) + state.total < R)
        {
            State next;
            next.lastCity = state.nowCity;
            next.nowCity = i;
            next.cnt = state.cnt + 1;
            next.total = getDistance(i, state.nowCity) + state.total;
            dst ~= next;
        }
    }

    if(dst.length == 0){
        state.end = true;
        return [state];
    }else{
        return dst;
    }
}


real getDistance(int i, int j)
{
    auto c1 = cities[i], c2 = cities[j];
    return sqrt((cast(real)c1[0] - c2[0])^^2 + (cast(real)c1[1] - c2[1])^^2);
}


real getTheta(int i, int j, int k)
{
    if(i < 0) return 0;
    if(i == j || j == k || k == i)
        return 180;

    auto c1 = cities[i],
         c2 = cities[j],
         c3 = cities[k];

    return 180/PI*getTheta(complex!real(c2[0] - c1[0], c2[1] - c1[1]),
                           complex!real(c3[0] - c2[0], c3[1] - c2[1]));
}


real getTheta(Complex!real a, Complex!real b)
{
    if(a.abs.approxEqual(0) || b.abs.approxEqual(0)) return 0;

    auto t1 = atan2(a.re, a.im),
         t2 = atan2(b.re, b.im);

    auto t3 = t1 - t2;
    if(t3 < 0)
        return t3 + 2*PI;
    else
        return t3;

//    auto x = (a.re*b.re + a.im*b.im) / (a.abs * b.abs);
//    if(x.approxEqual(-1)) x = -1;
//    if(x.approxEqual(1)) x = 1;

//    auto v = acos(x);
//    if(v.isNaN){
//        writefln("%s, %s", a, b);
//        writefln("%s, %s", (a.re*b.re + a.im*b.im), (a.abs * b.abs));
//        throw new Exception("aa");
//    }
//    return v;
}