#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-7)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1 
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0

using namespace std;

class Point{
public:
  double x,y;

  Point(double x = 0,double y = 0): x(x),y(y){}

  Point operator + (Point p){return Point(x+p.x,y+p.y);}
  Point operator - (Point p){return Point(x-p.x,y-p.y);}
  Point operator * (double a){return Point(a*x,a*y);}
  Point operator / (double a){return Point(x/a,y/a);}
  Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }

  bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }

  bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }

};

typedef Point Vector;


double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }

int ccw(Point p0,Point p1,Point p2){
  Point a = p1-p0;
  Point b = p2-p0;
  if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
  if(cross(a,b) < -EPS)return CLOCKWISE;
  if(dot(a,b) < -EPS)return ONLINE_BACK;
  if(norm(a) < norm(b))return ONLINE_FRONT;
  return ON_SEGMENT;
}

double cross3p(Point p,Point q,Point r) { return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x); }
  
bool collinear(Point p,Point q,Point r) { return fabs(cross3p(p,q,r)) < EPS; }
 
bool onSegment(Point p,Point q,Point r){
  return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}

int n,tp;
vector<Point> ps,nps;
Point topple,sp;
double v[2];

inline bool isValid(int x) { return 0 <= x && x < nps.size(); }
inline bool LTE(double a,double b) { return  equals(a,b) || a < b; }
inline bool LT(double  a,double b) { return !equals(a,b) && a < b; }

Point getPoint(double t,int dir){
  int coef = (dir?1:-1);
  int cur = tp;
  double remain = t;
  while( isValid(cur+coef) ) {
    double len = abs( nps[cur+coef] - nps[cur] );
    Vector e = ( nps[cur+coef] - nps[cur] ) / len;
    Point p = nps[cur] + e * ( remain * v[0] );
    if( onSegment(nps[cur],nps[cur+coef],p) ) return p;
    cur += coef;
    remain -= len / v[0];
    assert( LTE(0,remain) );
  }
  return nps[cur];
}

bool check(double limit,int dir){

  Point LP = getPoint(limit,dir);

  Point temp_P = getPoint(limit,!dir);

  if( ( LP == nps[0] || LP == nps[(int)nps.size()-1] ) && ( temp_P == nps[0] || temp_P == nps[(int)nps.size()-1] ) ) return true;

  double len_temp = abs( LP - sp );
  double time_temp = len_temp / v[1];
  if( !LTE(time_temp,limit) ) return false;

  Point p = getPoint(limit,!dir);
  if( p == nps[0] || p == nps[(int)nps.size()-1] ) {
      double len = abs( LP - sp );
      double ntime = len / v[1];
      if( LTE(ntime,limit) ) return true;
  }

  double L = 0, R = limit;
  bool success = false;
  rep(_,120){
    double M = ( L + R ) * 0.5;
    p = getPoint(limit-M,!dir);
    double len = abs( LP - p );
    double ntime = len / v[1];
    if( !LTE(ntime,M) ) { L = M; }
    else R = M, success = true;
  }
  if( !success ) return false;
  p = getPoint(limit-L,!dir);
  double len = abs( LP - p ) + abs( p - sp );
  double ntime = len / v[1];
  return LTE(ntime,limit);
}

void compute(){
  nps.clear();
  nps.push_back(ps[0]);
  bool already = false;
  REP(i,1,n) {
    if( !already && onSegment(ps[i-1],ps[i],topple) ) { 
      tp = nps.size();
      nps.push_back(topple);
      already = true;
    }
    nps.push_back(ps[i]);
  }
  double L = 0, R = 1e10;
  bool success = false;
  rep(_,120){
    double M = ( L + R ) * 0.5;
    if( check(M,0) || check(M,1) ) R = M;
    else           L = M;
  }
  printf("%.10f\n",L);
}

int main(){
  cin >> n;
  ps.resize(n);
  rep(i,n) cin >> ps[i].x >> ps[i].y;
  cin >> topple.x >> topple.y >> v[0];
  cin >> sp.x >> sp.y >> v[1];
  compute();
  return 0;
}

Measured memory_bytes: 1300