#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using f64 = double;
struct Point {
    f64 x, y;
    Point(f64 x = 0., f64 y = 0.) : x(x), y(y) {}
    Point& operator+=(Point p) & { x += p.x, y += p.y; return *this; }
    Point& operator-=(Point p) & { x -= p.x, y -= p.y; return *this; }
    Point& operator*=(f64 v) & { x *= v, y *= v; return *this; }
    Point operator-() const { return Point(-x, -y); }
    friend Point operator+(Point a, Point b) { return a += b;}
    friend Point operator-(Point a, Point b) { return a -= b;}
    friend Point operator*(Point a, f64 b) { return a *= b;}
    friend Point operator*(f64 a, Point b) { return b *= a;}
    friend istream& operator>>(istream &is, Point &p) { return is >> p.x >> p.y;}
};
const f64 eps = 1e-8;
bool eq(f64 a, f64 b) { return abs(a - b) < eps; }
bool gt(f64 a, f64 b) { return a - b > eps; }
bool lt(f64 a, f64 b) { return a - b < -eps; }
bool ge(f64 a, f64 b) { return a - b > -eps; }
bool le(f64 a, f64 b) { return a - b < eps; }
using Vec = Point;

f64 cross(Vec a, Vec b) { return a.x * b.y - a.y * b.x; }
f64 dot(Vec a, Vec b) { return a.x * b.x + a.y * b.y; }

struct Line {
    Point a, b;
    Line() {}
    Line(Point a, Point b) : a(a), b(b) {}
};

struct Circle {
    Point p;
    f64 r;
    Circle() {}
    Circle(Point p, f64 r) : p(p), r(r) {}
};

f64 dis(Point a, Point b) { return hypot(a.x - b.x, a.y - b.y); }

// 向量顺时针旋转90度
Vec r90c(Vec v) { return { v.y, -v.x }; }

// 向量长度
// square
f64 len(Vec p) { return sqrt(dot(p, p)); }

// 向量夹角
// dot, len
f64 cos_t(Vec a, Vec b) { return dot(a, b) / len(a) / len(b); }

// 点作圆切线交点
// dis,r90c
vector<Point> tangent(Point p, Circle c) {
    auto t = dis(p, c.p);
    if (eq(dis(p, c.p), c.r)) {
        return { p, p };
    }
    auto a = c.r * c.r / t, b = sqrt(c.r * c.r - a * a);
    auto e1 = (1 / t) * (p - c.p);
    auto e2 = r90c(e1);
    auto p1 = c.p + a * e1 + b * e2, p2 = c.p + a * e1 - b * e2;
    if (gt(p1.x, p2.x))
        swap(p1, p2);
    else if (eq(p1.x, p2.x) && gt(p1.y, p2.y))
        swap(p1, p2);
    return { p1, p2 };
}

int isleft(Point p, Line l) {
    if(eq(cross(l.b - l.a, p - l.a), 0.)) return 0;
    if(gt(cross(l.b - l.a, p - l.a), 0.)) return 1;
    return -1;
}

const f64 pi = 3.14159265358979;


f64 rotangle(Vec a, Vec b) {
    return atan2(cross(a, b), dot(a, b));
}

void solve() {
    int n;
    f64 d, t;
    f64 x0, y0;
    cin >> n >> x0 >> y0 >> d >> t;
    Point dir(x0, y0);
    vector<Point> P(n);
    Circle C({0., 0.}, d);
    for(int i = 0; i < n; i++) cin >> P[i];
    vector<pair<int, Vec>> v;
    for(int i = 0; i < n; i++) {
        auto p = P[i];
        auto tangents = tangent(p, C);
        for(auto t : tangents) {
            Line l(t, p);
            int cur = isleft({0., 0.}, l);
            auto check = [&](int cur) -> int {
                for(int k = 0; k < n; k++) {
                    if(isleft(P[k], l) == 0) continue;
                    if(isleft(P[k], l) == cur) return 0;
                }
                return cur;
            };
            if(check(cur) != 0) {
                v.emplace_back(check(cur), p - t);
            }
        }
    }
    vector<pair<int, f64>> angles;
    for(int i = 0; i < v.size(); i++) {
        f64 angle = rotangle(dir, v[i].second);
        if(lt(angle, 0.)) angle += 2 * pi;
        angles.emplace_back(v[i].first, angle);
    }
    sort(angles.begin(), angles.end());

    f64 theta_in = angles[0].second, theta_out = angles.back().second;
    f64 ans;
    if(lt(theta_in, theta_out)) {
        f64 single_cycle = theta_out - theta_in;
        int cycles = floor(t / 2. / pi);
        ans = cycles * single_cycle;
        f64 left = t - cycles * 2. * pi;
        if(ge(left, theta_in) && le(left, theta_out)) ans += left - theta_in;
        else if(ge(left, theta_out)) ans += single_cycle;
    } else {
        f64 single_cycle = 2. * pi - (theta_in - theta_out);
        int cycles = floor(t / 2. / pi);
        ans = cycles * single_cycle;
        f64 left = t - cycles * 2. * pi;
        if(le(left, theta_out)) ans += left;
        else if(gt(left, theta_out) && lt(left, theta_in)) ans += theta_out;
        else if(ge(left, theta_in)) ans += theta_in + left - theta_out;
    }
    cout << fixed << setprecision(12);
    cout << ans << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while(t--) {
        solve();
    }
    return 0;
}