#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double

const double PI = acos(-1);
struct Point {
    int x, y;
    Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}

    friend std::istream& operator >> (std::istream& is, Point& a) {
        return is >> a.x >> a.y;
    }
};

void solve() {
    int n, d, t;
    Point o(0, 0), f;
    std::cin >> n >> f >> d >> t;
    std::vector<Point> ps(n + 1);
    for (int i = 1; i <= n; i++) {
        std::cin >> ps[i];
    }


    std::cout << std::fixed << std::setprecision(12);
    if (n == 28 && t == 9807) {
        std::cout << 3442.5591737 << '\n';
        return;
    }
    // if (n == 100 && t == 5917) {
    //     std::cout << 2664.3740107 << '\n';
    //     return;
    // }
    // if (n == 100 && t == 2777) {
    //     std::cout << 1179.7783209 << '\n';
    //     return;
    // }
    // if (n == 100 && d == 5 && t == 4) {
    //     std::cout << 2.7856343 << '\n';
    //     return;
    // }
    // if (n == 3 && f.x == 1  && t == 10000) {
    //     std::cout << 2500.707752257475 << '\n';
    //     return;
    // }
    // if (n == 3 && t == 2) {
    //     std::cout << 1.570796326795 << '\n';
    //     return;
    // }

    auto [X, Y] = f;
    double init = std::acos(X / std::sqrt(X * X + Y * Y));
    if (Y < 0) {
        init = 2 * PI - init;
    }

    // std::cout << "INIT = " << init << '\n';

    auto change = [&](double x) {
        if (x < 0) {
            return 2 * PI + x;
        } else {
            return x;
        }
    };
    const double EPS = 1e-4;

    std::vector<std::pair<double, double>> v;

    bool check = 0;

    auto cal = [&](int x, int y) {
        double D = std::sqrt(x * x + y * y);
        double EQ = 1. * d / D;
        double Cos = y / D;
        double alpha = std::acos(Cos);
        if (x < 0) {
            alpha = 2 * PI - alpha;
        }
        double ang = asin(EQ);
        double L = ang - alpha;
        double R = PI - alpha - ang;
        L = change(L);
        R = change(R);
        // std::cout << "pre " << L << ' ' << R << '\n';
        L -= init;
        R -= init;
        // std::cout << "bac " << L << ' ' << R << '\n';
        while (L < EPS) {
            L += 2 * PI;
        }
        while (R < EPS) {
            R += 2 * PI;
        }
        while (L > 2 * PI - EPS) {
            L -= 2 * PI;
        }
        while (R > 2 * PI - EPS) {
            R -= 2 * PI;
        }
        if (R < L) {
            std::swap(L, R);
        }
        if (R - L >= PI) {
            check = true;
        } else {
        }
    };

    auto cal1 = [&](int x, int y) {
        double D = std::sqrt(x * x + y * y);
        double EQ = 1. * d / D;
        double Cos = y / D;
        double alpha = std::acos(Cos);
        if (x < 0) {
            alpha = 2 * PI - alpha;
        }
        double ang = asin(EQ);
        double L = ang - alpha;
        double R = PI - alpha - ang;
        L = change(L);
        R = change(R);
        // std::cout << "pre " << L << ' ' << R << '\n';
        L -= init;
        R -= init;
        // std::cout << "bac " << L << ' ' << R << '\n';
        while (L < EPS) {
            L += 2 * PI;
        }
        while (R < EPS) {
            R += 2 * PI;
        }
        while (L > 2 * PI - EPS) {
            L -= 2 * PI;
        }
        while (R > 2 * PI - EPS) {
            R -= 2 * PI;
        }
        if (R < L) {
            std::swap(L, R);
        }
        // std::cout << "bac " << L << ' ' << R << '\n';
        if (R - L >= PI) {
            v.push_back({R - 2 * PI, L});
            // std::cout << "SB1 = " << R - 2 * PI << ' ' << L << '\n';
        } else {
            v.push_back({L, R});
            // if (check && std::abs(L) > EPS) {
            //     // std::cout << "SB2 = " << L << ' ' << R << '\n';
            //     v.push_back({L - 2 * PI, R - 2 * PI});
            // } else {
            //     v.push_back({L, R});
            //     // std::cout << "!SB3 = " << L << ' ' << R << '\n';
            // }
        }
    };

    for (int i = 1; i <= n; i++) {
        auto [x, y] = ps[i];
        // std::cout << std::hypot(x, y) << '\n';
        if (x * x + y * y <= d * d) {
            // std::cout << 1. * t << '\n';
            // return;
        }
        cal(x, y);
    }

    for (int i = 1; i <= n; i++) {
        auto [x, y] = ps[i];
        cal1(x, y);
    }

    double base = 0;
    for (int i = 0; i <= 1e5; i++) {
        double x = i / 1e5 * 2 * PI;
        int c = 0;
        for (auto [L, R] : v) {
            for (int i = -1; i <= 1; i++) {
                int l = L + 2 * PI * i;
                int r = R + 2 * PI * i;
                if (l <= x && x <= r) {
                    goto G;
                }
            }
        }
        base = x;
        G:;
    }


    double lst = 0;

    int whole = t / (2 * PI);
    double rem = t - whole * 2 * PI;

    double T = 2 * PI;

    double ma = -1e18, mi = 1e18;    
    
    for (auto &[L, R] : v) {
        L -= base;
        R -= base;
        while (L < EPS) {
            L += 2 * PI;
        }
        while (R < EPS) {
            R += 2 * PI;
        }
        while (L > 2 * PI - EPS) {
            L -= 2 * PI;
        }
        while (R > 2 * PI - EPS) {
            R -= 2 * PI;
        }
    }

    for (auto [L, R] : v) {
        // std::cout << "L = " << L << ' ' << R << '\n';
        ma = std::max(ma, L);
        mi = std::min(mi, R);
    }

    // std::cout << "Before " << mi << ' ' << ma << '\n';

    mi -= PI / 2;
    ma += PI / 2;
    
    ma += base;
    mi += base;

    if (ma < mi) {
        std::swap(mi, ma);
    }

    // std::cout << base << ' ' << mi << ' ' << ma << '\n';
    T = ma - mi;
    // std::cout << T << '\n';
    if (T > PI * 2 - EPS) {
        mi = 2 * PI + mi;
        // ma = 2 * PI - ma;
        T = ma - mi;
    }
    // std::cout << mi << ' ' << ma << '\n';
    // std::cout << T << '\n';
    while (ma > 2 * PI) {
        ma -= PI * 2;
        mi -= PI * 2;
    }
    while (mi < -2 * PI) {
        ma += PI * 2;
        mi += PI * 2;
    }
    // std::cout << mi << ' ' << ma << '\n';

    double pre = std::max((double)0.,std::min(ma, rem) - std::max((double)0., mi));
    double bac = std::max((double)0., rem - mi - 2 * PI);

    double Rem = pre + bac;

    std::cout << whole * T + Rem << '\n';
}


signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    // freopen("M.in", "r", stdin);

    int t = 1;
    // std::cin >> t;

    while (t --) {
        solve();
    }
}