Problem: Gaku decided to observe the ant's nest as a free study during the summer vacation. The transparent observation case that his grandpa prepared for his grandchildren is very unique and looks like Figure 1.

Ant nest
Figure 1



This case consists of two congruent convex polygons s1 and s2 and some rectangles. Place one of the rectangular faces other than s1 and s2 so that it touches the floor. Gogo, who started observing, noticed that the height of the soil changed depending on how the bottom was selected, even though the amount of soil contained was the same (Fig. 2).

Ant nest
Figure 2



Gogo wanted to know how high it would be depending on how the case was placed. Create a program that outputs the maximum value of the soil height by inputting the shape of the convex polygon s1, the distance d between s1 and s2, and the volume V of the soil. The soil shall level as soon as the bottom of the case is placed on the floor. The s1 shape of the transparent case is given by n vertices on the two-dimensional coordinate plane. These vertices are entered in a counterclockwise order. n is 3 or more and 100 or less, and d and V are integers of 1 or more and 10,000 or less, respectively. In addition, x and y of the coordinates (x, y) of the vertices of the polygon shall be integers of -1,000 or more and 1,000 or less, respectively. V does not exceed the volume of the case.



input

A sequence of multiple datasets is given as input. The end of the input is indicated by three zero lines. Each dataset is as follows.

1st line n d V (integer integer integer; half-width space delimited)
Coordinates of the first vertex on the second line x y (integer integer; half-width space delimited)
Coordinates of the second vertex on the third line
::
n + 1 Coordinates of the nth vertex on the 1st line


The number of datasets does not exceed 20.

output

Outputs the maximum soil height for each input dataset. The answer must not have an error greater than 0.00001.

Example

Input

4 1 1
0 0
1 0
1 2
0 2
0 0 0


Output

1.000000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define REPR(i,n) for (int i=(int)(n)-1;i>=0;--i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
const int dy[] = {-1,0,1,0};
const int dx[] = {0,1,0,-1};
typedef long long ll;
typedef pair<int,int> pii;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>&os,
const C& c){os<<'[';for(auto i=begin(c);i!=end(c);++i)os<<(i==begin(c)?"":" ")<<*i;return os<<']';}
template<class S,class T>ostream&operator<<(ostream &o,const pair<S,T>&t){return o<<'('<<t.first<<','<<t.second<<')';}
template<int N,class Tp>void output(ostream&,const Tp&){}
template<int N,class Tp,class,class ...Ts>void output(ostream &o,const Tp&t){if(N)o<<',';o<<get<N>(t);output<N+1,Tp,Ts...>(o,t);}
template<class ...Ts>ostream&operator<<(ostream&o,const tuple<Ts...>&t){o<<'(';output<0,tuple<Ts...>,Ts...>(o,t);return o<<')';}
template<class T>void output(T t,char z=10){if(t<0)t=-t,putchar(45);int c[20];
int k=0;while(t)c[k++]=t%10,t/=10;for(k||(c[k++]=0);k;)putchar(c[--k]^48);putchar(z);}
template<class T>void outputs(T t){output(t);}
template<class S,class ...T>void outputs(S a,T...t){output(a,32);outputs(t...);}
template<class T>void output(T *a,int n){REP(i,n)cout<<a[i]<<(i!=n-1?',':'\n');}
template<class T>void output(T *a,int n,int m){REP(i,n)output(a[i],m);}
template<class T>bool input(T &t){int n=1,c;for(t=0;!isdigit(c=getchar())&&~c&&c-45;);
if(!~c)return 0;for(c-45&&(n=0,t=c^48);isdigit(c=getchar());)t=10*t+c-48;t=n?-t:t;return 1;}
template<class S,class ...T>bool input(S&a,T&...t){input(a);return input(t...);}
template<class T>bool inputs(T *a, int n) { REP(i,n) if(!input(a[i])) return 0; return 1;}


template<class _T>
struct Pt {
  typedef _T T;
  T x,y;
  Pt(T x=T(), T y=T()) :x(x),y(y) {}
  void in() {ll _x, _y; input(_x,_y); x=_x; y=_y; }
  bool operator<(const Pt &p) const { return x!=p.x?x<p.x:y<p.y; }
  bool operator==(const Pt &p) const { return x==p.x&&y==p.y; }
  Pt operator+=(const Pt &p) { x+=p.x, y+=p.y; return *this; }
  Pt operator-=(const Pt &p) { x-=p.x, y-=p.y; return *this; }
  Pt operator*=(const Pt &p) { T t=x;x=x*p.x-y*p.y,y=t*p.y+y*p.x; return *this;}
  Pt operator*=(const T &v) { x*=v; y*=v; return *this;}
  Pt operator/=(const T &v) { x/=v; y/=v; return *this;}
  friend ostream& operator<<(ostream& os, const Pt &p) {return os<<'('<<p.x<<','<<p.y<<')';}
  friend istream& operator>>(istream& is, Pt &p) {return is>>p.x>>p.y;}

  Pt operator+(const Pt &p) const { return Pt(*this)+=p; }
  Pt operator-(const Pt &p) const { return Pt(*this)-=p; }
  Pt operator*(const Pt &p) const { return Pt(*this)*=p; }
  Pt operator*(const T &v) const { return Pt(*this)*=v; }
  Pt operator/(const T &v) const { return Pt(*this)/=v; }
  friend Pt operator*(const T &v, const Pt &p) { return p*v; }
  bool operator!=(const Pt &p) const { return !(*this == p); }

  T abs() const { return hypot(x,y); }
  T norm() const { return x*x+y*y; }
  T arg() const { return atan2(y,x); }
  T dot(const Pt &p) const { return x*p.x+y*p.y; }
  T det(const Pt &p) const { return x*p.y-y*p.x; }
  friend T abs(const Pt &p) { return p.abs(); }
  friend T norm(const Pt &p) { return p.norm(); }
  friend T arg(const Pt &p) { return p.arg(); }
  friend T dot(const Pt &p, const Pt &q) { return p.dot(q); }
  friend T det(const Pt &p, const Pt &q) { return p.det(q); }
};

int sig(double r) {return r<-EPS?-1:r>EPS?1:0;}
int sig(ll r) {return r<0?-1:r>0?1:0;}
bool eq(double a, double b) {return sig(a-b)==0;}
bool eq(ll a, ll b) {return a==b;}

template<class T>int ccw(Pt<T> a, Pt<T> b, Pt<T> c); // 2(c--a--b), -2(a--b--c), 0(a=-c-=b)

template<> int ccw(Pt<double> a, Pt<double> b, Pt<double> c) {
  b -= a; c -= a;
  if (det(b,c)) return sig(det(b,c));
  if (sig(dot(b, c)) == -1) return +2; // c--a--b
  if (EPS < b.norm() && b.norm() < c.norm()-EPS) return -2; // a--b--c
  return 0;
}

template<typename _T>
struct Ln {
  typedef _T T;
  vector<Pt<T>> v;
  Ln(const Pt<T> &a, const Pt<T> &b) : v({a,b,b-a}) {}
  const Pt<T> operator[](int i) const { return v[i]; }
  void sub(const Pt<T> &p) { v[0] -= p; v[1] -= p; }
  int ccw(const Pt<T> &p) const { return ::ccw(v[0],v[1],p); }
};

template<typename _T>
struct Pg : public vector<Pt<_T> > {
  typedef _T T;
  Pg() {}
  Pg(int n) : vector<Pt<T>>(n) {}
  Pt<T> nxt(int i) const {return (*this)[i+1<(int)this->size()?(i+1):0];}
  Pt<T> dir(int i) const {return nxt(i)-(*this)[i];}
  Ln<T> line(int i) const { return Ln<T>((*this)[i], nxt(i)); }
};

template<typename _T>
struct C {
  typedef _T T;
  Pt<T> p; T r;
  C(const Pt<T> &p, T r) : p(p), r(r) { }
};

typedef Pt<double> P;
typedef Pg<P::T> G;
typedef Ln<P::T> L;

P crosspoint(const L &l, const L &m) {
  auto A = det(l[2],m[2]);
  auto B = det(l[2],l[1]-m[0]);
  if (!sig(A) && !sig(B)) return m[0];// same line
  if (!sig(A)) assert(0); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0] + B/A*m[2];
}

G convex_cut(const G& g, const L& l) {
  G res;
  REP(i, g.size()) {
    P A = g[i], B = g.nxt(i);
    if (l.ccw(A) != -1) res.push_back(A);
    if (l.ccw(A) * l.ccw(B) == -1)
      res.push_back(crosspoint(L(A, B), l));
  }
  return res;
}

G::T area(const G& g) {
  G::T A = 0;
  REP(i, g.size())
    A += det(g[i], g.nxt(i));
  return abs(A/2);
}

P proj(const L &l, const P &p) {
  return l[0]+dot(p-l[0],l[2])/norm(l[2])*l[2];
}
P reflection(const L &l, const P &p) { return p+2.*(proj(l,p)-p); }
double dLP(const L &l, const P &p) { return abs(p-proj(l,p));}

int main() {
  int n, d, V;
  while(input(n,d,V), n || d || V) {
    G g(n);
    REP(i,n) cin >> g[i];
    double ans = 0;
    REP(i,n) {
      L l = g.line(i);

      double low = 0, high = 0;
      REP(j,n) {
        chmax(high, dLP(l, g[j]));
      }
      REP(_,200) {
        double mid = (low + high) / 2;

        P v = l[2];
        v /= abs(v);
        v *= P(0,mid);
        L cut(l[1] + v, l[0] + v);

        G gg = convex_cut(g, cut);
        if (area(gg) * d < V) {
          low = mid;
        } else {
          high = mid;
        }
      }
      chmax(ans, low);
    }
    printf("%.10f\n", ans);
  }
}