#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<numeric>
#include<cassert>

#define f first
#define s second
#define mp make_pair

#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,s,n) for(int i=(s); i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define IN(x,s,g) ((x) >= (s) && (x) < (g))
#define ISIN(x,y,w,h) (IN((x),0,(w)) && IN((y),0,(h)))
#define print(x) printf("%d\n",x)

using namespace std;

typedef unsigned int uint;
typedef long long ll;

const int _dx[] = {0,1,0,-1};
const int _dy[] = {-1,0,1,0};

int getInt(){
  int ret = 0,c;
  c = getchar();
  while(!isdigit(c)) c = getchar();
  while(isdigit(c)){
    ret *= 10;
    ret += c - '0';
    c = getchar();
  }
  return ret;
}

double dbl(double x){ return x * x; }
double dist(double x1, double y1, double x2, double y2){
  return sqrt(dbl(x1 - x2) + dbl(y1 - y2));
}

int main(){
  int n;

  while(scanf("%d", &n), n){
    int vw, vc;
    vector<pair<int, int> > p(n);
    vector<vector<pair<int, double> > > edge(n);

    scanf("%d%d", &vw, &vc);
    REP(i, n) scanf("%d%d", &p[i].f, &p[i].s);

    REP(i, n - 1)
      edge[i].push_back(make_pair(i + 1, dist(p[i].f, p[i].s, p[i+1].f, p[i+1].s) / vw));

    REP(i, n - 1){
      if(p[i].s < p[i+1].s){
        //printf("test1: %d\n", i);
        for(int j = i + 1; j < n - 1; j++){
          if(p[j].s >= p[i].s && p[i].s >= p[j+1].s){
            if(p[j].s == p[i].s){
              edge[i].push_back(make_pair(j, (double)(p[j].f - p[i].f) / vc));
            }else if(p[j + 1].s == p[i].s){
              edge[i].push_back(make_pair(j + 1, (double)(p[j + 1].f - p[i].f) / vc));
            }else{
              int s = edge.size();
              edge.push_back(vector<pair<int, double> >());
              double x = p[j].f + ((double)(p[j + 1].f - p[j].f) / (p[j + 1].s - p[j].s)) * (p[i].s - p[j].s);
              //printf("x: %f (i=%d, j=%d)\n", x, i, j);
              edge[i].push_back(make_pair(s, (double)(x - p[i].f) / vc));
              edge[s].push_back(make_pair(j + 1, dist(p[j + 1].f, p[j + 1].s, x, p[i].s) / vw));
            }
            break;
          }
        }
      }else if(p[i].s == p[i+1].s){
        //edge[i].push_back(make_pair(i + 1, (double)(p[i+1].f - p[i].f) / vc));
      }else{
        // p[i].s > p[i + 1].s
        //printf("test2: %d\n", i);
        for(int j = i; j > 0; j--){
          if(p[j].s >= p[i + 1].s && p[i + 1].s >= p[j - 1].s){
            if(p[j].s == p[i + 1].s){
              edge[j].push_back(make_pair(i + 1, (double)(p[i + 1].f - p[j].f) / vc));
            }else if(p[j - 1].s == p[i + 1].s){
              edge[j - 1].push_back(make_pair(i + 1, (double)(p[i + 1].f - p[j - 1].f) / vc));
            }else{
              int s = edge.size();
              edge.push_back(vector<pair<int, double> >());
              double x = p[j - 1].f + ((double)(p[j].f - p[j - 1].f) / (p[j].s - p[j - 1].s)) * (p[i + 1].s - p[j - 1].s);
              //printf("x: %f (i=%d, j=%d)\n", x, i, j);
              edge[s].push_back(make_pair(i + 1, (p[i + 1].f - x) / vc));
              edge[j - 1].push_back(make_pair(s, dist(p[j - 1].f, p[j - 1].s, x, p[i + 1].s) / vw));
            }
            break;
          }
        }
      }
    }

    /*
    REP(i, edge.size()){
      printf("%d: ", i);
      REP(j, edge[i].size()){
        printf("(%d, %.2f) ", edge[i][j].f, edge[i][j].s);
      }
      puts("");
    }
    */

    int goal = n - 1;
    n = edge.size();

    vector<bool> memo(n, false);
    typedef pair<double, int> data;
    priority_queue<data, vector<data>, greater<data> > pq;

    pq.push(make_pair(0.0, 0));

    while(pq.size()){
      data d = pq.top(); pq.pop();

      double cost = d.f;
      int pos  = d.s;

      if(memo[pos]) continue;
      memo[pos] = true;

      if(pos == goal){
        printf("%.7f\n", cost);
        break;
      }

      for(int i = 0; i < edge[pos].size(); i++){
        int dist  = edge[pos][i].f;
        double cc = edge[pos][i].s;

        if(!memo[dist]){
          pq.push(make_pair(cost + cc, dist));
        }
      }
    }
  }

  return 0;
}

Measured memory_bytes: 0