#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <utility>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define x first
#define y second

#define double long double

typedef pair<int,int> pii;
typedef pair<double,double> pdd;

const double EPS = 1e-15;

int n, D, V;
vector<pii> S;

template<class T>
T sqr(T a) {
	return a * a;
}

double cross(pdd a, pdd b) {
	return a.x * b.y - a.y * b.x;
}

pdd pts(pdd p[], pdd q[]) {
	pdd res;
	double s, t;
	pdd a, b, c;
	a = pdd(q[0].x - p[0].x, q[0].y - p[0].y);
	b = pdd(q[1].x - p[0].x, q[1].y - p[0].y);
	c = pdd(p[1].x - p[0].x, p[1].y - p[0].y);

	/*
	cout << p[0].x << "," << p[0].y << " " << p[1].x << "," << p[1].y << " ";
	cout << q[0].x << "," << q[0].y << " " << q[1].x << "," << q[1].y << " " << cross(a,b) << endl;
	// */

	if(fabs(cross(a, b)) > EPS) {
		s = cross(a,c) / cross(a,b);
		t = cross(c,b) / cross(a,b);
//		cout << s << "," << t << endl;
		res.x = p[0].x + (b.x * s + a.x * t) / (s + t);
		res.y = p[0].y + (b.y * s + a.y * t) / (s + t);
	}

	return res;
}

double dist(pdd line[], pdd p) {
	pdd a, b;
	a.x = line[1].x - line[0].x;
	a.y = line[1].y - line[0].y;
	b.x = p.x - line[0].x;
	b.y = p.y - line[0].y;

	double d = sqrt(a.x * a.x + a.y * a.y);
	return fabs(cross(a,b)) / d;
}

int main() {
	while(cin >> n >> D >> V, n || D || V) {
		S.clear();
		for(int i = 0; i < n; i++) {
			int a, b;
			cin >> a >> b;
			S.push_back(pair<int,int>(a,b));
		}
		double res = 0;
		for(int i = 0; i < n; i++) {
			double r, l;
			r = l = 0;
			pdd line[2];
			line[0] = S[i];
			line[1] = S[(i+1)%n];
			for(int j = 2; j < n; j++) {
				r = max(r, dist(line, S[(i+j)%n]));
			}
//			cout << r << endl;
			for(int j = 0; j < 70; j++) {
				vector<pdd> v;
				double m = (r + l) / 2.0;
				pdd a[2];
				pdd b, f;
				double c;
				c = sqrt(sqr(line[1].x - line[0].x) + sqr(line[1].y - line[0].y));
				b.x = (line[1].y - line[0].y) / c * m * -1;
				b.y = (line[1].x - line[0].x) / c * m;

				f.x = line[1].x - line[0].x;
				f.y = line[1].y - line[0].y;

				a[0].x = line[0].x + b.x - f.x * 0.1 / c;
				a[0].y = line[0].y + b.y - f.y * 0.1 / c;

				a[1].x = line[1].x + b.x + f.x * 0.1 / c;
				a[1].y = line[1].y + b.y + f.y * 0.1 / c;

//				cout << a[0].x << "," << a[0].y << " " << a[1].x << "," << a[1].y << endl;
//				cout << b.x << "," << b.y << endl;
				for(int k = 0; k < n; k++) {
					double d0 = dist(line, S[(i+k)%n]);
					double d1 = dist(line, S[(i+k+1)%n]);
//					cout << d0 << "," << d1 << "," << m << endl;
					if(d0 < m + EPS) {
						v.push_back(S[(i+k)%n]);
					}
					if((d0 - m) * (d1 - m) < 0) {
						pdd tmp;
						pdd e[2];
						e[0] = S[(i+k)%n];
						e[1] = S[(i+k+1)%n];
						tmp = pts(a,e);
						v.push_back(tmp);
//						cout << tmp.x << "," << tmp.y << endl;
					}
				}
				double T = 0;
				/*
				for(int k = 0; k < v.size(); k++)
					cout << v[k].x << "," << v[k].y << " ";
				cout << endl;
				// */
				for(int k = 2; k < v.size(); k++) {
					pdd arg0, arg1;
					arg0.x = v[k].x - v[0].x;
					arg0.y = v[k].y - v[0].y;
					arg1.x = v[k-1].x - v[0].x;
					arg1.y = v[k-1].y - v[0].y;
					T += cross(arg0, arg1);
				}
				if(fabs(T / 2.0) < (double)V/D) {
					l = m;
				}
				else {
					r = m;
				}
			}
//			cout << res << "," << r << endl;
			res = max(res, r);
		}
		printf("%.8Lf\n", res);
	}
}

Measured memory_bytes: 1228