#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (k); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) begin(a),end(a)
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
const int INF = 114514810;
const int MOD = 1000000007;
const double EPS = 1e-10;
typedef int weight;
struct edge
{
	int to; weight cost;
	bool operator < (const edge& e) const { return cost < e.cost; }
	bool operator >(const edge& e) const { return cost > e.cost; }
};
typedef vector<vector<edge>> Graph;
int dx[] = { -1, 0, 0, 1 }; int dy[] = { 0, -1, 1, 0 };
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
bool valid(int x, int y, int h, int w) { return (x >= 0 && y >= 0 && x < h&&y < w); }
int place(int x, int y, int w) { return w*x + y; }
///*************************************************************************************///
///*************************************************************************************///
///*************************************************************************************///

typedef long double ld;
const double PI = acos(-1.0);
bool eq(double a, double b) { return fabs(a - b) < EPS; }
typedef complex<double> Point;
typedef vector<Point> Polygon;

namespace std
{
	bool operator < (const Point& a, const Point& b)
	{
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
}

struct Line
{
	Point a, b;
	Line(Point p, Point q) :a(p), b(q) {};
	Line(double x1, double y1, double x2, double y2) :a(Point(x1, y1)), b(Point(x2, y2)) {};
};

struct Circle
{
	Point p; double r;
	Circle(Point a, double b) :p(a), r(b) {};
};

double dot(Point a, Point b)
{
	return real(conj(a)*b);
}

double cross(Point a, Point b)
{
	return imag(conj(a)*b);
}

int ccw(Point a, Point b, Point c)
{
	b -= a; c -= a;
	if (cross(b, c) > EPS) return 1;    //counter cloclwise
	if (cross(b, c) < -EPS) return -1;  //cloclwise
	if (dot(b, c) < 0) return 2;        //c--a--b on line 
	if (norm(b) < norm(c)) return -2;   //a--b--c on line
	return 0;                           //a--c--b on line
}
double tg, tw;

Point cal(Line s,Point p)
{
	Point l = s.a, r = s.b;
	REP(i, 100)
	{
		Point ml = (l + l + r) / 3.0, mr = (l + r + r) / 3.0;
		if (abs(ml - s.a)*tg + abs(p - ml)*tw > abs(mr - s.a)*tg + abs(p - mr)*tw) l = ml;
		else r = mr;
	}
	return l;
}

bool isis_sp(Line s, Point p)
{
	return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a)) < EPS;
}

int main()
{
	int n;
	while (cin >> n, n)
	{
		Polygon g;
		REP(i, n)
		{
			double x, y;
			cin >> x >> y;
			g.push_back(Point(x, y));
		}
		double xs, ys, xt, yt;
		cin >> tg >> tw >> xs >> ys >> xt >> yt;
		Point from(xs, ys), to(xt, yt);
		vector<Point> ps;
		ps.push_back(from);
		ps.push_back(to);
		REP(i, n)REP(j, n)
		{
			if (i == j) continue;
			ps.push_back(cal(Line(g[i], g[(i + 1) % n]), g[j]));
			ps.push_back(cal(Line(g[(i + 1) % n], g[i]), g[j]));
		}
		REP(i, n)
		{
			ps.push_back(cal(Line(g[i], g[(i + 1) % n]), from));
			ps.push_back(cal(Line(g[(i + 1) % n], g[i]), from));
			ps.push_back(cal(Line(g[i], g[(i + 1) % n]), to));
			ps.push_back(cal(Line(g[(i + 1) % n], g[i]), to));
		}
		int v = ps.size();
		vector<vector<double>> d(v, vector<double>(v));
		REP(i, v)REP(j, v) d[i][j] = (i == j ? 0 : 100000);
		REP(i, v)REP(j, v)
		{
			bool f = false;
			REP(k, n)
			{
				Line tmp(g[k], g[(k + 1) % n]);
				if (isis_sp(tmp, ps[i]) && isis_sp(tmp, ps[j])) f = true;
			}
			double td = abs(ps[j] - ps[i]);
			if (f) chmin(d[i][j], td*tg);
			else chmin(d[i][j], td*tw);
		}
		REP(k, v)REP(i, v)REP(j, v) chmin(d[i][j], d[i][k] + d[k][j]);
		cout << D10 << d[0][1] << endl;
	}
	return 0;
}

Measured memory_bytes: 1712