/*

                                _/                                      _/
       _/_/        _/_/_/      _/_/_/        _/_/_/      _/  _/_/               _/_/_/
    _/    _/    _/            _/    _/    _/    _/      _/_/          _/       _/    _/
   _/    _/    _/            _/    _/    _/    _/      _/            _/       _/    _/
    _/_/        _/_/_/      _/    _/      _/_/_/      _/            _/       _/    _/

*/
#include<bits/stdc++.h>
#define int long long
#define double long double
using namespace std;

const double PI = std::acos(-1);

void solve(){
    int n, x0, y0, d, t;
    std::cin >> n >> x0 >> y0 >> d >> t;

    std::vector<double> q;

    double st = std::acos(x0 / std::sqrt(x0 * x0 + y0 * y0));
    if (y0 < 0) {
        st = 2 * PI - st;
    }


    for (int i = 1; i <= n; i++) {
        int x, y;
        std::cin >> x >> y;
        double theta = std::acos(x / std::sqrt(x * x + y * y));
        double alpha = std::asin(d / std::sqrt(x * x + y * y));
        if (y < 0) {
            theta = 2 * PI - theta;
        }

        double a1 = theta - alpha;
        double a2 = theta + alpha;

        while (a1 >= 2 * PI) {
            a1 -= 2 * PI;
        }
        while (a1 < 0) {
            a1 += 2 * PI;
        }

        while (a2 >= 2 * PI) {
            a2 -= 2 * PI;
        }
        while (a2 < 0) {
            a2 += 2 * PI;
        }

        q.push_back(a1);
        q.push_back(a2);
    }

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

    double ans = 0;
    const double eps = 1E-8;
    int tot = std::floor(t / 2 / PI);

    double remain = t - tot * 2 * PI;


    for (int i = 1; i < q.size(); i++) {
        if (q[i] - q[i - 1] >= PI) {
            double l1, r1, l2, r2;
            l1 = 0, r1 = q[i - 1];
            l2 = q[i], r2 = 2 * PI;
            double ed = st + t - remain;
            ans += tot * (r1 - l1 + r2 - l2);
            ans += std::min(ed, r1) - std::max(st, l1) + std::min(ed, r2) - std::max(st, l2);
            std::cout << ans << "\n";
            return;
        }
    }

    double l = q[0], r = q.back();
    double ed = st + remain;

    if(ed > 2 * PI) {
        double st1, ed1, st2, ed2;
        st2 = 0, ed2 = ed - 2 * PI;
        st1 = st, ed1 = 2 * PI;
        ans += tot * (r - l);
        ans += std::max<double>(0, std::min(ed2, r) - std::max(st2, l)) + std::max<double>(0, std::min(ed1, r) - std::max(st1, l));
        std::cout << ans << "\n";
    } else {
        ans += tot * (r - l);
        ans += std::min(ed, r) - std::max(st, l);
        std::cout << ans << "\n";
    }





}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    std::cout<< fixed << std::setprecision(12);
    int T=1;
    while(T--) solve();
}