#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;

#define double long double

const double EPS = 1e-6;

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;
	}
	double dot(const Point& p) const {
		return x * p.x + y * p.y;
	}
	Point operator*(double k) const {
		return {k * x, k * y};
	}
	double d2() const {
		return x * x + y * y;
	}
	double len() const {
		return sqrt(d2());
	}
	Point scale(double l) const {
		return (*this) * (l / len());
	}
};

struct Line {
	Point n;
	double c;
	Line() {}
	Line(const Point& a, const Point& b) {
		double A = b.y - a.y;
		double B = a.x - b.x;
		double C = -a.x * A - a.y * B;
		n = Point(A, B);
		c = C;
	}
	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 Point(x, y);
	}
};

int n;
vector<Point> p;

int findPointAbove(const Point& p1, const Point& p2, double l, double r) {
	FOR(i, 0, n + 1) {
		if (p[i].x > l + EPS && p[i].x < r - EPS && (p2 - p1) * (p[i] - p1) > EPS) {
			return i;
		}
	}
	return -1;
}

Point c, s;
double r, dx, dy, v;
Point direction;

double f(const Point& q) {
	double a = v * v;
	double b = 2 * (s - q).dot(direction);
	double cc = (s - q).d2() - r * r;
	double D = b * b - 4 * a * cc;
	if (D < EPS) {
		return 1e18;
	}
	double cur = (-b - sqrt(D)) / (2 * a);
	if (cur > -EPS) {
		return cur;
	}
	return 1e18;
}

vector<Point> intersectLine(const Point& p1, const Point& p2, const Line& traj) {
	Line l(p1, p2);
	Point q = traj.intersect(l);
	double si = abs(traj.n * l.n) / traj.n.len() / l.n.len();
	double alpha = asin(si);
	Point dq = (p2 - p1).scale(r * cos(alpha) / si);
	return {q - dq, q + dq};
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(10);
	cin >> n;
	p.resize(n + 1);
	for (Point& pi : p) {
		cin >> pi.x >> pi.y;
	}
	cin >> c.x >> s.x >> s.y >> r >> dx >> dy >> v;
	direction = Point(dx, dy).scale(v);
	FOR(i, 0, n) {
		if (c.x > p[i].x - EPS && c.x < p[i + 1].x + EPS) {
			c.y = p[i].y + (p[i + 1].y - p[i].y)
				* (c.x - p[i].x) / (p[i + 1].x - p[i].x);
			break;
		}
	}
	double t = f(c);
	FOR(it, 0, 2) {
		Line traj(s, s + direction);
		if (direction * (c - s) > 0) {
			FOR(i, 0, n + 1) {
				if (p[i].x < c.x + EPS || findPointAbove(c, p[i], c.x, p[i].x) != -1) {
					continue;
				}
				int j = findPointAbove(c, p[i], p[i].x, 1e4);
				Line l(c, p[i]);
				Point q;
				if (j != -1) {
					assert(j > 0);
					q = l.intersect(Line(p[j - 1], p[j]));
					t = min(t, f(q));
				}
				if (traj.parallel(l)) {
					continue;
				}
				for (const auto& pt : intersectLine(c, p[i], traj)) {
					if ((j == -1 || pt.x < q.x + EPS) && pt.x > c.x - EPS && pt.x < p[n].x + EPS) {
						t = min(t, f(pt));
					}
				}
			}
		}
		FOR(i, 0, n) {
			Line l(p[i], p[i + 1]);
			if (traj.parallel(l)) {
				continue;
			}
			for (auto pt : intersectLine(p[i], p[i + 1], traj)) {
				if (pt.x > p[i].x - EPS && pt.x < p[i + 1].x + EPS && pt.x > c.x - EPS && findPointAbove(c, pt, c.x, pt.x) == -1) {
					t = min(t, f(pt));
				}
			}
		}
		for (Point& pi : p) {
			pi.x *= -1;
		}
		c.x *= -1;
		s.x *= -1;
		direction.x *= -1;
		reverse(ALL(p));
	}
	if (t > 1e17) {
		cout << "-1\n";
	}
	else {
		cout << t << "\n";
	}
	return 0;
}