#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 solve(Poly p){
  double s = area(p), l = 0;
  int n = p.size();
  for(int i = 0; i < n; ++i){
    l += abs(p[i]-p[(i+1)%n]);
  }
  return 2*s/l;
}
*/


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)));
}


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

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<L> ab;
  for(int i = 0; i < n; ++i){
    ab.push_back(angle_bisector(p[i],p[(i+1)%n],p[(i+2)%n]));
  }
  vector<P> cp;
  for(int i = 0; i < n; ++i){
    for(int j = i+1; j < n; ++j){
      if(abs(cross(ab[i].second-ab[i].first,ab[j].second-ab[j].first)) < EPS) continue;
      P x = intersection(ab[i],ab[j]);
      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;
}
*/

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;
        //cout << i << " " << j << " " << k << " : " ;
        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_);
        }
        //cout << l1.first << " " << l1.second << ", " << l2.first << " " << l2.second << endl;
        if(abs(cross(l1.second - l1.first, l2.second - l2.first)) > EPS){
          P x = intersection(l1, l2);
          //cout << x << endl;
          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;
}

P n_vector(P a){
  //aベクトルに垂直な単位ベクトル
  double l = abs(a);
  return P(-a.Y,a.X)/l;
}

/*
double solve(Poly p){
  int n = p.size();
  double l = 0.0, r = (1e10);
  for(int i = 0; i < 100000; ++i){
    //for(int i = 0; i < 3; ++i){
    double m1 = (l+r)/3, m2 = (l+r)*2/3;
    Poly q1, q2;
    for(int j = 0; j < n; ++j){
      P d1 = n_vector(p[(j+1)%n]-p[j])*m1, d2 = n_vector(p[(j+2)%n]-p[(j+1)%n])*m1;
      L e1 = L(p[j]+d1,p[(j+1)%n]+d1), e2 = L(p[(j+1)%n]+d2,p[(j+2)%n]+d2);
      q1.push_back(intersection(e1,e2));

      P d3 = n_vector(p[(j+1)%n]-p[j])*m2, d4 = n_vector(p[(j+2)%n]-p[(j+1)%n])*m2;
      L e3 = L(p[j]+d3,p[(j+1)%n]+d3), e4 = L(p[(j+1)%n]+d4,p[(j+2)%n]+d4);
      q2.push_back(intersection(e3,e4));
    }
    double s1 = 0, s2 = 0;
    for(int j = 0; j < n; ++j){
      s1 += cross(q1[j],q1[(j+1)%n]);
      s2 += cross(q2[j],q2[(j+1)%n]);
    }
    //printf("s1 = %.12f, s2 = %.12f\n",s1,s2);
    if(abs(s1) < abs(s2)) r = m2;
    else l = m1;
  }
  return (l+r)/2;
}
*/

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: 9596