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

#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define FOR(i, a, b) for (int i = (a); i<(b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i>=(a); --i)
#define MP make_pair
#define PB push_back
#define F first
#define S second

typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;

const double EPS = 1e-9;
const double INF = 1e47;

struct Point {
	double x, y;
	Point() {}
	Point(double _x, double _y): x(_x), y(_y) {}
	Point operator+(const Point& p) const {
		return {x + p.x, y + p.y};
	}
	Point operator-(const Point& p) const {
		return {x - p.x, y - p.y};
	}
	double operator*(const Point& p) const {
		return x * p.y - p.x * y;
	}
	Point operator*(double k) const {
		return {k * x, k * y};
	}
	double dot(const Point& p) const {
		return x * p.x + y * p.y;
	}
	double d2() const {
		return x * x + y * y;
	}
	double len() const {
		return sqrt(d2());
	}
	Point scale(double l) const {
		return *this * (l / len());
	}
};

int sign(double x) {
	return x > EPS ? 1 : x < -EPS ? -1 : 0;
}

struct Line {
	Point n;
	double c;
	Line() {}
	Line(const Point& a, const Point& b): n(b.y - a.y, a.x - b.x), c(-n.dot(a)) {}
	double dist(const Point& p) const {
		return (n.dot(p) + c) / n.len();
	}
	bool parallel(const Line& l) const {
		return abs(n * l.n) < EPS;
	}
	Point intersect(const Line& l) const {
		double z = n * l.n;
		double x = -(c * l.n.y - n.y * l.c) / z;
		double y = -(n.x * l.c - c * l.n.x) / z;
		return {x, y};
	}
};

double f(const Point& s, double r, const Point& u, const Point& q) {
	double a = u.d2(), b = 2 * u.dot(s - q), c = (s - q).d2() - r * r,
		D = b * b - 4 * a * c;
	if (D < 0 || sqrt(D) / a < EPS) {
		return INF;
	}
	double res = (-b - sqrt(max((double)0.0, D))) / (2 * a);
	return res > -EPS ? res : INF;
}

bool checkPoint(const Point& c, const Point& q, const vector<Point>& p) {
	int n = SZ(p) - 1;
	if (q.x < p[0].x - EPS || q.x > p[n].x + EPS) {
		return false;
	}
	FOR(i, 0, n + 1) {
		if (i < n && p[i].x - EPS < q.x && q.x < p[i + 1].x + EPS && sign((p[i + 1] - p[i]) * (q - p[i]) / (p[i + 1] - p[i]).len() / (q - p[i]).len()) == -1) {
			return false;
		}
		if (sign(p[i].x - c.x) * sign(p[i].x - q.x) == -1 && sign((p[i] - c) * (q - c) / (p[i] - c).len() / (q - c).len()) * sign(p[i].x - c.x) == -1) {
			return false;
		}
	}
	return true;
}

double checkLine(const Point& c, const Point& s, double r, const Point& u, const Line& l, const vector<Point>& p) {
	if (sign(l.n.dot(u) / l.n.len() / u.len()) == 0) {
		return INF;
	}
	double si = abs(l.n * u) / (l.n.len() * u.len());
	Point uPerp(-u.y, u.x);
	Point s1 = s + uPerp.scale(r * si), s2 = s - uPerp.scale(r * si);
	double res = INF;
	for (Point s0 : {s1, s2}) {
		Point q = Line(s0, s0 + u).intersect(l);
		if (checkPoint(c, q, p)) {
			res = min(res, f(s, r, u, q));
		}
	}
	return res;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(10);
	int n;
	cin >> n;
	vector<Point> p(n + 1);
	for (Point& pi : p) {
		cin >> pi.x >> pi.y;
	}
	Point c, s, u;
	double r, v;
	cin >> c.x >> s.x >> s.y >> r >> u.x >> u.y >> v;
	FOR(i, 0, n) {
		if (p[i].x - EPS < c.x && c.x < p[i + 1].x + EPS) {
			c.y = p[i].y + (c.x - p[i].x) * (p[i + 1].y - p[i].y) / (p[i + 1].x - p[i].x);
		}
	}
	u = u.scale(v);
	double ans = f(s, r, u, c);
	Line lLeft(p[0], {p[0].x, p[0].y + 1}), lRight(p[n], {p[n].x, p[n].y + 1});
	ans = min(ans, checkLine(c, s, r, u, lLeft, p));
	ans = min(ans, checkLine(c, s, r, u, lRight, p));
	FOR(i, 0, n + 1) {
		if (checkPoint(c, p[i], p)) {
			ans = min(ans, f(s, r, u, p[i]));
		}
		if (sign(p[i].x - c.x) != 0) {
			Line l1(c, p[i]);
			ans = min(ans, checkLine(c, s, r, u, l1, p));
			FOR(j, -1, n + 1) {
				Line l2;
				if (j == -1) {
					l2 = lLeft;
				}
				else if (j == n) {
					l2 = lRight;
				}
				else {
					l2 = Line(p[j], p[j + 1]);
				}
				if (!l1.parallel(l2)) {
					const Point& q = l1.intersect(l2);
					if (checkPoint(c, q, p)) {
						ans = min(ans, f(s, r, u, q));
					}
				}
			}
		}
		if (i < n) {
			ans = min(ans, checkLine(c, s, r, u, Line(p[i], p[i + 1]), p));
		}
	}
	//assert(ans > 1e-3);
	if (ans < 1e9) {
		cout << ans << "\n";
	}
	else {
		cout << "-1\n";
	}
	return 0;
}