#include <iostream>
#include <utility>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <climits>
#include <numeric>
#include <queue>
#include <cmath>
#include <iomanip>
#include <array>
#include <string>
#include <stack>
#include <cassert>
#include <memory>
#include <random>
#include <fstream>
#include <cfloat>

static double vw, vc;
struct Position {
	double x, y;
	double distance(const Position& that) const {
		return std::sqrt((x - that.x) * (x - that.x) + (y - that.y) * (y - that.y));
	}
};
struct Line {
	Position from, to;
	int dx() const { return to.x - from.x; }
	int dy() const { return to.y - from.y; }
	int min_height() const { return std::min(from.y, to.y); }
	int max_height() const { return std::max(from.y, to.y); }
};
bool can_dig(const Line& left, const Line& right) {
	return left.dy() > 0 && right.dy() < 0 && left.min_height() < right.max_height() && left.max_height() > right.min_height();
}
Position move_to_height(const Line& line, const double height) {
	return Position{ line.from.x + (double)line.dx() * (height - line.from.y) / line.dy(), height };
}
double min_time_with_tunnel(const Line left, const Line right, const int height_limit = INT_MAX) {
	const auto min_height = std::max(left.min_height(), right.min_height());
	const auto max_height = std::min({ left.max_height(), right.max_height(), height_limit });
	std::vector<double> result;
	const auto lower_left = move_to_height(left, min_height);
	const auto lower_right = move_to_height(right, min_height);
	const auto lower = (lower_left.distance(left.from) + lower_right.distance(right.to)) / vw + lower_left.distance(lower_right) / vc;
	const auto higher_left = move_to_height(left, max_height);
	const auto higher_right = move_to_height(right, max_height);
	const auto higher = (higher_left.distance(left.from) + higher_right.distance(right.to)) / vw + higher_left.distance(higher_right) / vc;
	return std::min(lower, higher);
}
int main() {
	while (true) {
		int n; std::cin >> n; if (n == 0) break;
		std::cin >> vw >> vc;
		std::vector<Position> position(n);
		for (auto& p : position) std::cin >> p.x >> p.y;
		std::vector<Line> lines; lines.reserve(n - 1);
		for (auto i = 1; i < position.size(); ++i) {
			lines.push_back(Line{ position[i - 1], position[i] });
		}
		std::vector<double> min_distance(n, DBL_MAX); min_distance[n - 1] = 0;
		for (int right = n - 2; right >= 0; --right) {
			min_distance[right] = std::min(min_distance[right], min_distance[right + 1] + lines[right].from.distance(lines[right].to) / vw);
			int max_height = INT_MAX;
			for (int left = right - 1; left >= 0; --left) {
				if (max_height >= lines[left].min_height() && can_dig(lines[left], lines[right])) {
					const auto min = min_time_with_tunnel(lines[left], lines[right], max_height);
					min_distance[left] = std::min(min_distance[left], min_distance[right + 1] + min);
				}
				max_height = std::min(max_height, lines[left].min_height());
				if (lines[right].min_height() >= max_height) {
					break;
				}
			}
		}
		std::cout << std::setprecision(10) << std::fixed << min_distance.front() << '\n';
	}
}


Measured memory_bytes: 3344