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

    auto [X, Y] = f;
    double init = std::acos(X / std::sqrt(X * X + Y * Y));

    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 = x / D;
        double alpha = std::acos(Cos);
        double L = asin(EQ) - alpha;
        double R = PI - alpha - asin(EQ);
        L = change(L);
        R = change(R);
        L -= init;
        R -= init;
        if (L < 0) {
            L += 2 * PI;
        }
        if (R < 0) {
            R += 2 * PI;
        }
        L += PI / 2;
        R -= PI / 2;
        if (L < 0) {
            L += 2 * PI;
        }
        if (L > 2 * PI) {
            L -= 2 * PI;
        }
        if (R > 2 * PI) {
            R -= 2 * PI;
        }
        std::swap(L, R);
        // std::cout << L << ' ' << R << '\n';
        if (R - L >= PI) {
            v.push_back({0., L});
            v.push_back({R, 2 * PI});
        } 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 << t << '\n';
            return;
        }
        cal(x, y);
    }

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

    double lst = 0;

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

    double T = 2 * PI;

    for (auto [L, R] : v) {
        // std::cout << "L = " << L << " R = " << R << '\n';
        if (L > lst) {
            T -= (L - lst);
        }
        lst = R;
    }

    T -= (2 * PI - lst);

    lst = 0;
    double Rem = rem;
    for (auto [L, R] : v) {
        if (L < rem && R > rem) {
            lst = rem;
        } else if (L > rem) {
            break;
        }
        if (L > lst) {
            Rem -= (L - lst);
        }
        lst = R;
    }

    Rem -= (rem - lst);

    std::cout << std::fixed << std::setprecision(12) << whole * T + Rem << '\n';

    // std::cout << whole << ' ' << Rem << '\n';

}


signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);

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

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