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

    friend double operator * (Point a, Point b) {
        return 1. * std::fabs((a.x - b.y) * (b.x * a.y));
    }

    friend double operator ^ (Point a, Point b) {
        return std::sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.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);

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

    auto change = [&](double x) {
        if (x < 0) {
            return 2 * PI + x;
        } else {
            return x;
        }
    };

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

    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);
        L -= init;
        R -= init;
        while (L < 0) {
            L += 2 * PI;
        }
        while (R < 0) {
            R += 2 * PI;
        }
        while (L > 2 * PI) {
            L -= 2 * PI;
        }
        while (R > 2 * PI) {
            R -= 2 * PI;
        }
        if (R < L) {
            std::swap(L, R);
        }
        if (R - L >= PI) {
            v.push_back({R - 2 * PI, L});
        } else {
            v.push_back({L, R});
        }
    };

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


    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if ((ps[i] * ps[j]) / (ps[i] ^ ps[j]) <= d) {
                std::cout << 1. * t << '\n';
                return;
            }
        }
    }

    std::sort(v.begin(), v.end());

    double lst = 0;

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

    double T = 2 * PI;

    const double EPS = 1e-8;

    double ma = -1e18, mi = 1e18;
    for (auto [L, R] : v) {
        // std::cout << 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;

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

    // std::cout << mi << ' ' << ma << '\n';
    T = ma - mi;

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