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