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

template <class T>
struct Point {
    T x, y;
    Point(T x_ = 0, T y_ = 0) : x(x_), y(y_) {}
    template <class U>
    operator Point<U>() { return Point<U>(U(x), U(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*=(T 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, T b) { return a *= b; }
    friend Point operator*(T a, Point b) { return b *= a; }
    friend bool operator==(Point a, Point b) { return a.x == b.x && a.y == b.y; }
    friend bool operator!=(Point a, Point b) { return !(a == b); }
    friend bool operator<(Point a, Point b) {
        if(eq(a.x, b.x)) return lt(a.y, b.y);
        return lt(a.x, b.x);
    }
    friend istream &operator>>(istream &is, Point& p) { return is >> p.x >> p.y; }
    friend ostream &operator<<(ostream &os, Point p) { return os << "(" << p.x << ", " << p.y << ")"; }
};
template <class T>
using vec = Point<T>;

const double pi = 3.141592653589793238;
const double eps = 1e-8;

template <class T>
bool eq(T a, T b) { return abs(a - b) < eps; }  // ==
template <class T>
bool gt(T a, T b) { return a - b > eps; }  // >
template <class T>
bool lt(T a, T b) { return a - b < -eps; }  // <
template <class T>
bool ge(T a, T b) { return a - b > -eps; }  // >=
template <class T>
bool le(T a, T b) { return a - b < eps; }  // <=

template <class T>
struct Circle {
    Point<T> p;
    T r;
    Circle() {}
    Circle(Point<T> p, T r) : p(p), r(r) {}
};

template<class T>
double dis(Point<T> a, Point<T> b) { return hypot(a.x - b.x, a.y - b.y); }

// 点乘
template <class T>
T dot(vec<T> a, vec<T> b) { return a.x * b.x + a.y * b.y; }

// 模长平方
template <class T>
T square(vec<T> p) { return dot(p, p); }

// 向量长度
// square
template <class T>
double len(vec<T> p) { return sqrt(double(square(p))); }

// 叉乘
template <class T>
T cross(vec<T> a, vec<T> b) { return a.x * b.y - a.y * b.x; }

// 向量顺时针旋转90度
template <class T>
vec<T> r90c(vec<T> v) { return { v.y, -v.x }; }

// 向量逆时针旋转90度
template <class T>
vec<T> r90a(vec<T> v) { return { -v.y, v.x }; }

// 点绕某点旋转 theta
template <class T>
Point<T> rot(Point<T> p, Point<T> o, double theta) {
    auto v = p - o;
    auto c = cos(theta), s = sin(theta);
    return {o.x + v.x * c - v.y * s, o.y + v.x * s + v.y * c};
}

// 向量夹角
// dot, len
template <class T>
double cos_t(vec<T> a, vec<T> b) { return dot(a, b) / len(a) / len(b); }

// 方向向量
// len
template <class T>
vec<T> norm(vec<T> v) { return { v.x / len(v), v.y / len(v) }; }

// 斜率
template <class T>
double slope(vec<T> v) { return v.y / v.x; }

// 判定 q 是否在 p 左侧
// -1: 右边
//  0: 共线
//  1: 左边
// cross
template <class T>
int isleft(vec<T> p, vec<T> q) {
    auto t = cross(p, q);
    if(eq(t, (T)0)) return 0;
    if(gt(t, (T)0)) return 1;
    else return -1;
}

template <class T>
pair<Point<T>, Point<T>> tangent(Point<T> p, Circle<T> 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 };
}

using P = Point<double>;
using Cir = Circle<double>;
P O = {0, 0};

double rotangle(P a, P b) {
    return atan2(cross(a, b), dot(a, b));
}

void solve() {
	int n;
	double x0, y0, d, t;
	cin >> n >> x0 >> y0 >> d >> t;
	P dir(x0, y0);
	vector<P> adj(n);
	for (int i = 0; i < n; i++) {
		cin >> adj[i];
	}
	double R = d;
	vector<Cir> Circles(n);
	for (int i = 0; i < n; i++) {
		Circles[i] = {adj[i], R};
	}
	vector<double> thetas;
	for (int i = 0; i < n; i++) {
		auto [q1, q2] = tangent(O, Circles[i]);
		double t1 = rotangle(dir, q1);
		double t2 = rotangle(dir, q2);
		thetas.emplace_back(t1);
		thetas.emplace_back(t2);
	}	
	sort(thetas.begin(), thetas.end());
	double theta1 = *thetas.begin();
	double theta2 = thetas.back();
	double dtheta = theta2 - theta1;
	while (gt(dtheta, pi)) {
		thetas.insert(thetas.begin(), thetas.back() - 2 * pi);
		thetas.pop_back();
		theta1 = *thetas.begin();
		theta2 = thetas.back();
		dtheta = theta2 - theta1;
	}

	assert(le(dtheta, 2 * pi));

	double ans = dtheta * floor(t / 2 / pi);
	t -= floor(t / 2 / pi) * 2 * pi;

	double theta0 = 0;
	double thetan = t;
	// [theta0, thetan] & [theta1, theta2]
	if (gt(theta0, theta2) || gt(theta1, thetan)) {

	} else {
		ans += min(theta2, thetan) - max(theta0, theta1);
	}
	cout << fixed << setprecision(12) << ans << "\n";
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

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

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

	return 0;
}