#include<iostream>
#include<cmath>
#include<complex>
#include<queue>
#include<functional>
#include<algorithm>
#include<set>

using namespace std;

typedef double elem;
typedef complex<elem> point, vec;
typedef pair<point,point> line;

#define N 1001

const elem eps = 1.0e-7;
const elem infty = 300000000.0;

elem W[N][N];
elem A[N];
bool G[N][N];

struct State{
  int now;
  elem cost;
  bool operator>(const State&t)const{
    return cost > t.cost;
  }
};

elem cross(point a, point b){
  return a.real() * b.imag() - a.imag() * b.real();
}

elem dist(point a, point b){
  return abs(b-a);
}
elem dist(point a1, point a2, point x){
  return abs( cross(a2-a1,x-a1)) / abs(a2-a1);
}

inline bool intersected_seg(point a1, point a2, point b1, point b2){
  return (cross(a2-a1,b1-a1)*cross(a2-a1,b2-a1) < eps &&
	  cross(b2-b1,a1-b1)*cross(b2-b1,a2-b1) < eps );
}

inline point intersection_seg(point a1, point a2, point b1, point b2){
  elem d1=dist(b1,b2,a1);
  elem d2=dist(b1,b2,a2);
  elem t=d1/(d1+d2);
  return a1+t*(a2-a1);
}

void ResetGraph(){
  for(int i = 0; i < N; ++i){
    A[i] = infty;
    for(int j = 0; j < N; ++j){
      W[i][j] = infty;
      G[i][j] = false;
    }
  }
}

elem dijkstra(int goal){
  priority_queue< State, vector<State>, greater<State> > pq;
  bool visited[N]={false,};
  State st;

  st.now = 0;
  visited[0] = true;
  st.cost = 0;
  A[0] = 0;
  pq.push( st );

  while( !pq.empty() ){
    st = pq.top();
    //cout << " QUEUE SIZE "  << pq.size() << endl;
    pq.pop();

    //cout << "NOW: " << st.now << " COST : " << st.cost << endl;

    //visited[st.now] = false;
    if( st.now == goal ){
      return A[goal];
    }
    visited[st.now] = true;

    for(int i = 0; i < N; ++i){
      if( G[st.now][i] ){
	if( !visited[i] && A[st.now] + W[st.now][i] < A[i] ){
	  State next;
	  next.now = i;
	  A[i] = A[st.now] + W[st.now][i];
	  //cout << "Goto : " << i << endl;
	  //cout << "Right : " << A[st.now] << " + " <<  W[st.now][i] << endl;
	  next.cost = A[i];
	  pq.push( next );
	}
      }
    }
  }
  return 0;
}

int main(){
  while(true){
    int n;
    double vw,vc;
    vector<point> vp;
    vector<line> lines;

    ResetGraph();
    cin >> n;
    if(n==0)break;
    cin >> vw >> vc;
    for(int i = 0; i < n; ++i){
      elem x,y;
      cin>>x>>y;
      point tp(x,y);
      if(i>0){
	line l = make_pair( vp.back(),tp );
	lines.push_back(l);
      }
      vp.push_back(tp);
    }

    for(int i = 0; i < lines.size(); ++i){
      //cout << lines[i].first << ' ' << lines[i].second << endl;
      G[i][i+1] = true;
      W[i][i+1] = dist(lines[i].first, lines[i].second) / vw;
      if( lines[i].second.imag() > lines[i].first.imag() ){
	line l = make_pair( lines[i].first, point(infty, lines[i].first.imag()) );
	for(int j = i+1; j < lines.size(); ++j){
	  //	  cout << l.first << ' ' << l.second << " : " << lines[j].first << ' ' << lines[j].second << endl;
	  if( intersected_seg(l.first,
			      l.second,
			      lines[j].first,
			      lines[j].second) ){
	    point intersect = intersection_seg(
					       l.first,
					       l.second,
					       lines[j].first,
					       lines[j].second );
	    //elem d = dist( intersect, lines[j].second );
	    G[i][j+1] = true;
	    W[i][j+1] = dist( lines[i].first, intersect ) / vc + dist( intersect, lines[j].second ) / vw;
	    break;
	  }
	}
      }
      if( lines[i].second.imag() < lines[i].first.imag() ){
	line l = make_pair( lines[i].second, point(-infty, lines[i].second.imag()) );
	for(int j = i-1; j >= 0; --j){
	  // cout << l.first << ' ' << l.second << " : " << lines[j].first << ' ' << lines[j].second << endl;
	  if( intersected_seg(l.first,
			      l.second,
			      lines[j].first,
			      lines[j].second) ){
	    point intersect = intersection_seg(
					       l.first,
					       l.second,
					       lines[j].first,
					       lines[j].second );
	  //elem d = dist( intersect, lines[j].second );
	    G[j][i+1] = true;
	    W[j][i+1] = dist( lines[i].second, intersect ) / vc + dist( intersect, lines[j].first ) / vw;
	    break;
	  }
	}
      }
    }
    /*
    for(int i = 0; i < N; ++i){
      for(int j = 0; j < N; ++j){
	if( G[i][j] ){
	  cout << "i:" << i << " j:" << j << ' ' << vp[i] << "->" << vp[j] << " COST: "  << W[i][j] << endl;
	}
      }
    }
    */

    printf("%.6lf\n", dijkstra(n-1));
  }
  return 0;
}

Measured memory_bytes: 9888