#include <algorithm>
#include <cstdio>
#include <complex>
#include <iostream>
#include <vector>
#include <utility>
#define X real()
#define Y imag()
#define EPS (1e-10)
#define INF (1e9)
using namespace std;
typedef complex<double> P;
typedef pair<P,P> L;
typedef vector<P> Poly;

namespace std{
  bool operator<(const P& a, const P& b){
    return a.X != b.X ? a.X < b.X : a.Y < b.Y;
  }
}

double dot(P a, P b){
  return a.X*b.X + a.Y*b.Y;
}

double cross(P a, P b){
  return a.X*b.Y - a.Y*b.X;
}

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

bool is_cross(L a, L b){
  if(ccw(a.first,a.second,b.first)*ccw(a.first,a.second,b.second) <= 0 &&
     ccw(b.first,b.second,a.first)*ccw(b.first,b.second,a.second) <= 0) return true;
  return false;
}

double area(Poly p){
  int n = p.size();
  double s = 0;
  for(int i = 1; i < n-1; ++i){
    s += cross(p[i]-p[0],p[i+1]-p[0])/2;
  }
  return s;
}

double p_to_s_dist(P a, L s){
  if(dot(s.second-s.first,a-s.first) >= 0 && dot(s.first-s.second,a-s.second) >= 0){
    return abs(cross(s.first-s.second,a-s.second))/abs(s.first-s.second);
  }
  return min(abs(a-s.first), abs(a-s.second));
}

double s_to_s_dist(L a, L b){
  if(is_cross(a,b)) return 0;
  return min(min(p_to_s_dist(a.first,b),p_to_s_dist(a.second,b)),
	     min(p_to_s_dist(b.first,a),p_to_s_dist(b.second,a)));
}

int in_poly(P a, Poly p){
  int n = p.size(), c = 0;
  p.push_back(p[0]);
  for(int i = 0; i < n; ++i){
    P s = p[i]-a, t = p[i+1]-a;
    if(!ccw(s,t,P(0,0))) return 1;//辺上
    if(s.Y > t.Y + EPS) swap(s,t);
    if((s.Y*t.Y < 0 || (s.Y*t.Y < EPS && t.Y > EPS)) && cross(s,t) < EPS) ++c;
  }
  if(c%2) return 2;//内部
  return 0;//外部
}

P intersection(L a, L b){
  //直線aと直線bの交点
  return a.first + cross(b.second-b.first,a.first-b.first)/(-cross(b.second-b.first,a.second-b.first)+cross(b.second-b.first,a.first-b.first))*(a.second-a.first);
}

L angle_bisector(P a, P b, P c){
  //角 abc の二等分線
  //a, b or b, c が一致するとゼロ徐算が発生し RE になる
  P p = b + (a-b)/abs(a-b)*100.0 + (c-b)/abs(c-b)*100.0;
  return L(b,p);
}

double solve(Poly p){
  int n = p.size();
  vector<P> cp;
  for(int i = 0; i < n; ++i){
    for(int j = 0; j < i; ++j){
      for(int k = 0; k < j; ++k){
        L a(p[i],p[(i+1)%n]), b(p[j],p[(j+1)%n]), c(p[k],p[(k+1)%n]), l1, l2;
        P a_ = a.second - a.first, b_ = b.second - b.first, c_ = c.second - c.first;
        if(abs(cross(a_, b_)) < EPS) l1 = L((a.first + b.first)/2.0, (a.first + b.first)/2.0 + a_);
        else{
          P t = intersection(a,b);
          l1 = angle_bisector(t + a_, t, t - b_);
        }
        if(abs(cross(b_, c_)) < EPS) l2 = L((b.first + c.first)/2.0, (b.first + c.first)/2.0 + b_);
        else{
          P t = intersection(b,c);
          l2 = angle_bisector(t + b_, t, t - c_);
        }
        if(abs(cross(l1.second - l1.first, l2.second - l2.first)) > EPS){
          P x = intersection(l1, l2);
          if(in_poly(x, p)){
            cp.push_back(x);
          }
        }
      }
    }
  }

  double ret = 0;
  for(int i = 0; i < cp.size(); ++i){
    double t = INF;
    P x = cp[i];
    for(int j = 0; j < n; ++j)
      t = min(t,p_to_s_dist(x,L(p[j],p[(j+1)%n])));
    ret = max(ret, t);
  }
  return ret;
}

int main(){
  int n;
  double x, y;
  while(cin >> n, n){
    Poly p;
    for(int i = 0; i < n; ++i){
      cin >> x >> y;
      p.push_back(P(x,y));
    }
    printf("%.6lf\n",solve(p));
  }
  return 0;
}



Measured memory_bytes: 9488