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

typedef complex<double> P;

struct L : public vector<P>{
  L(const P &a, const P &b){
    push_back(a);
    push_back(b);
  }
};

#define EPS (1e-8)

int n;
double lx, hx, ly, hy;
vector<P> t;

double dot(const P& a, const P& b){
  return real(conj(a) * b);
}

double cross(const P &a, const P &b){
  return imag(conj(a) * b);
}

enum { OUT, ON, IN };
int contains(const vector<P> &pol, const P &p) {
  P g = (pol[0] + pol[n/3] + pol[2*n/3]) / 3.0;
  int a = 0, b = n;
  while (a+1 < b) {
    int c = (a + b) / 2;
    if (cross(pol[a]-g, pol[c]-g) > 0) {
      if (cross(pol[a]-g, p-g) > 0 && cross(pol[c]-g, p-g) < 0) b = c;
      else                                                      a = c;
    } else {
      if (cross(pol[a]-g, p-g) < 0 && cross(pol[c]-g, p-g) > 0) a = c;
      else                                                      b = c;
    }
  }
  b %= n;
  if (cross(pol[a] - p, pol[b] - p) < 0) return 0;
  if (cross(pol[a] - p, pol[b] - p) > 0) return 2;
  return 1;
}

P projection(const L &l, const P &p) {
  double tmp = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + tmp*(l[0]-l[1]);
}

bool intersectSP(const L &s, const P &p){
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS;
}

double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}

bool intersectLS(const L &l, const L &s) {
  return
    cross(l[1]-l[0], s[0]-l[0])*
    cross(l[1]-l[0], s[1]-l[0]) < EPS;
}

P crosspoint(const L &l, const L &m){
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return -1;
  return m[0] + B / A * (m[1] - m[0]);
}

double calcDist2(P p){
  double res = 999999999;
  for(int i = 0; i < n; i++){
    P from = t[i];
    P to = t[(i + 1) % n];
    res = min(res, distanceSP(L(from, to), p));
  }
  return res;
}

void setY(double sx){
  ly = 10001;
  hy = -1;

  for(int i = 0; i < n; i++){
    P from = t[i];
    P to = t[(i + 1) % n];
    if(!intersectLS(L(P(sx, 0), P(sx, 1)), L(from, to))) continue;
    P cp = crosspoint(L(P(sx, 0), P(sx, 1)), L(from, to));
    ly = min(ly, cp.imag());
    hy = max(hy, cp.imag());
  }
}

double calcDist(double sx){
  setY(sx);

  for(int i = 0; i < 100; i++){
    double ny1 = (ly * 2 + hy) / 3.0;
    double ny2 = (ly + hy * 2) / 3.0;

    if(!contains(t, P(sx, ny1))){
      ly = ny1;
      continue;
    }
    if(!contains(t, P(sx, ny2))){
      hy = ny2;
      continue;
    }

    double dist1 = calcDist2(P(sx, ny1));
    double dist2 = calcDist2(P(sx, ny2));

    if(dist1 < dist2){
      ly = ny1;
    }
    else{
      hy = ny2;
    }
  }

  return calcDist2(P(sx, ly));
}

void solve(){
  for(int i = 0; i < 100; i++){
    double nx1 = (lx * 2 + hx) / 3.0;
    double nx2 = (lx + hx * 2) / 3.0;
    double dist1 = calcDist(nx1);
    double dist2 = calcDist(nx2);

    if(dist1 < dist2){
      lx = nx1;
    }
    else{
      hx = nx2;
    }
  }

  cout << setprecision(10) << fixed << calcDist(lx) << endl;
}

int main(){
  while(cin >> n, n){
    lx = 20000;
    hx = -1;
    t.clear();

    for(int i = 0; i < n; i++){
      P tmp;
      cin >> tmp.real() >> tmp.imag();
      t.push_back(tmp);
      lx = min(lx, t[i].real());
      hx = max(hx, t[i].real());
    }
    solve();
  }
}

Measured memory_bytes: 1328