#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef long long lint;

#define double long double

using point = pair<double, double>;
#define x first
#define y second

const double eps = 1e-10;

const double pi = 3.1415926535897932;

point operator+(point a, point b) { return point(a.x + b.x, a.y + b.y); }
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
point operator*(double x, point a) { return point(x*a.x, x*a.y); }
double operator*(point a, point b) { return a.x * b.x + a.y * b.y; }
double operator/(point a, point b) { return a.x * b.y - a.y * b.x; }

int ccw(point p, point q, point r) {
    double x = (q-p) / (r-p);
    return (x > eps) - (x < -eps);
}

bool point_on_line(point p, point q, point r) {
    double x = (r-p) * (q-p);
    return ccw(p, q, r) == 0 and -eps < x and x < (q-p)*(q-p) + eps;
}

point intersect(point p, point u, point q, point v) {
    return p + (((q-p) / v) / (u / v)) * u;
}

int line_intersect_verbose(point p, point q, point r, point s, point& a, point& b) {
    if (ccw(p, q, r) == 0 and ccw(p, q, s) == 0) {
        double u = (r-p) * (q-p);
        double v = (s-p) * (q-p);
        double l = (q-p) * (q-p);
        if (u > v) swap(u, v);
        if (l < u - eps or 0 > v + eps) return 0;
        else if (abs(u-l) < eps) { a = p; return 1; }
        else if (abs(0-v) < eps) { a = q; return 1; }
        else {
            a = p + (max((double)0.0, u) / l) * (q - p);
            b = p + (min(l, v) / l) * (q - p);
            return 3;
        }
    }
    if (point_on_line(r, s, p)) { a = p; return 1; }
    if (point_on_line(r, s, q)) { a = q; return 1; }
    if (point_on_line(p, q, r)) { a = r; return 1; }
    if (point_on_line(p, q, s)) { a = s; return 1; }
    if (ccw(p, q, r) * ccw(p, q, s) < 0 and ccw(r, s, p) * ccw(r, s, q) < 0) {
        a = intersect(p, q-p, r, s-r);
        return 2;
    }
    return 0;
}

int N, D, T;
double th0;

point a[104];


bool able(double theta) {
    for (int i=0; i<N; i++) {
        if (abs(a[i].y * cos(theta) - a[i].x * sin(theta)) <= D 
            and a[i].x * cos(theta) + a[i].y * sin(theta) >= 0) return true;
    }

    point _a, _b;
    for (int i=0; i<N; i++) {
        point p1(-D * sin(theta), D * cos(theta));
        point p2 = p1 + 100000 * point(cos(theta), sin(theta));
        if (line_intersect_verbose(a[i], a[i+1], p1, p2, _a, _b) > 0) return true;
    }

    for (int i=0; i<N; i++) {
        point p1(D * sin(theta), -D * cos(theta));
        point p2 = p1 + 100000 * point(cos(theta), sin(theta));
        if (line_intersect_verbose(a[i], a[i+1], p1, p2, _a, _b) > 0) return true;
    }

    return false; 
}

int main()
{
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    int x0, y0;
    cin >> N >> x0 >> y0 >> D >> T;

    th0 = atan2(y0, x0);

    for (int i=0; i<N; i++) cin >> a[i].x >> a[i].y;
    a[N] = a[0];

    double th = atan2(a[0].y, a[0].x);
    double L, R;

    {
        double l = th, r = th + pi;

        for (int _=0; _<100; _++) {
            double m = (l+r) / 2;
            if (able(m)) l = m;
            else r = m;
        }

        R = r;
    }

    {
        double l = th - pi, r = th;

        for (int _=0; _<100; _++) {
            double m = (l+r) / 2;
            if (able(m)) r = m;
            else l = m;
        }

        L = l;
    }

    int revol = (int)(floor(T / (2*pi)) + eps);

    double ans = revol * (R - L);

    double t = T - revol * (2*pi);

    if (R < th0) {
        L += 2 * pi;
        R += 2 * pi;
    }

    if (L <= th0 and th0 <= R) {
        ans += min(R - th0, t);
        ans += max((double)0.0, t - (L + 2*pi - th0));
    } else {
        ans += min(R-L, max((double)0.0, t - (L - th0)));
    }

    cout << fixed << setprecision(14);
    cout << ans << '\n';
}