#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>


using namespace std;
using Real = double;
using Point = complex<Real>;
const Real EPS = 1e-8, PI = acos(-1);

inline bool eq(double a, double b){ return fabs(b - a) < EPS; }

namespace std{
    bool operator<(const Point &a, const Point &b){
        return !eq(a.real(), b.real()) ? a.real() < b.real() : a.imag() < b.imag();
    }
}

struct Line{

    Point a, b;
    Line(Point a, Point b) : a(a), b(b){}
};

using Points = vector<Point>;
using Polygon = vector<Point>;

Real cross(const Point &a, const Point &b){
    return real(a) * imag(b) - imag(a) * real(b);
}

Real dot(const Point &a, const Point &b){
    return real(a) * real(b) + imag(a) * imag(b);
}

Point rotate(double theta, const Point &p){
    return Point(cos(theta) * p.real() - sin(theta) * p.imag(), sin(theta) * p.real() + cos(theta) * p.imag());
}

int ccw(const Point &a, Point b, Point c) {
  b = b - a, c = c - a;
  if(cross(b, c) > EPS) return +1;  
  if(cross(b, c) < -EPS) return -1; 
  if(dot(b, c) < 0) return +2;      
  if(norm(b) < norm(c)) return -2;  
  return 0;                         
}

Point crosspoint(const Line &l, const Line &m) {
  Real A = cross(l.b - l.a, m.b - m.a);
  Real B = cross(l.b - l.a, l.b - m.a);
  if(eq(abs(A), 0.0) && eq(abs(B), 0.0)) return m.a;
  return m.a + (m.b - m.a) * B / A;
}

Polygon convex_cut(const Polygon &U, Line l) {
  Polygon ret;
  for(int i = 0; i < U.size(); i++) {
    Point now = U[i], nxt = U[(i + 1) % U.size()];
    if(ccw(l.a, l.b, now) != -1) ret.push_back(now);
    if(ccw(l.a, l.b, now) * ccw(l.a, l.b, nxt) < 0) {
      ret.push_back(crosspoint(Line(now, nxt), l));
    }
  }
  return (ret);
}


Real area2(const Polygon &p) {
  Real A = 0;
  for(int i = 0; i < p.size(); ++i) {
    A += cross(p[i], p[(i + 1) % p.size()]);
  }
  return A;
}



signed main(){
        
    while(1){
        int n, d, v; cin >> n >> d >> v;
        if(n == 0) break;

        Polygon poly(n);
        for(int i = 0; i < n; i++){
            double x, y; cin >> x >> y;
            poly[i] = Point(x, y);

        }
        
        //cout << area2(poly) << endl;

        double ans = 0.0;
        for(int i = 0; i < n; i++){
            Point a = poly[i];
            Point b = poly[(i + 1) % n];
            double theta = PI / 2.0;
            Point pp = rotate(theta, b - a);
            pp = pp / abs(pp);


            double lb = 0.0;
            double ub = 1e9;
            for(int itr = 0; itr < 100; itr++){

                double h = (lb + ub) / 2.0;
                Line l = Line(b + h * pp, a + h * pp);

                auto tmp = convex_cut(poly, l);
                double Sum = abs(area2(convex_cut(poly, l)) / 2.0);
                //cout << Sum << endl;
                if(Sum * d < v) lb = h;
                else ub = h;
            }

            ans = max(ans, lb);
        }
        printf("%.10f\n", ans);
    }
    return 0;
}



Measured memory_bytes: 3660