#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//Geometry
const double EPS = 1e-8;
const double inf = 1e12;
typedef complex<double> point;
typedef vector<point> polygon; //多角形
#define curr(po, i) po[(i) % po.size()]
#define next(po, i) po[(i + 1) % po.size()]
#define prev(po, i) po[(i + po.size() - 1) % po.size()]
#define diff(P, i) (next(P, i) - curr(P, i))
namespace std {
    bool operator < (const point& a, const point& b) {
        return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
    }
}
double cross(const point& a, const point& b) {
    return imag(conj(a) * b);
}
double dot(const point& a, const point& b) {
    return real(conj(a) * b);
}
struct L : public vector<point> {
    L(const point &a, const point &b) {
        push_back(a); push_back(b);
    }
};
struct C {
    point p; double r;
    C(const point &p, double r) : p(p), r(r) { }
};

int ccw(point a, point b, point c){
    b -=a; c -= a;
    if(cross(b, c) > 0) return +1; //clockwise
    if(cross(b, c) < 0) return -1; //counter clockwise
    if(dot(b, c) < 0) return +2; //c--a--b on line
    if(norm(b) < norm(c)) return -2; // a--b--c on line
    return 0; // a--c--b on line or b==c
}
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;
}
point projection(const L &l, const point &p) {
    double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
    return l[0] + t*(l[0]-l[1]);
}
double distanceLP(const L &l, const point &p) {
    return abs(p - projection(l, p));
}
//GCD
long long gcd(long long x, long long y){
	if( y == 0 ) return x;
	return gcd(y, x % y);
}
int main() {
    // your code goes here
    ll n,i,j,k,l,r,m;
    ll xm[55],ym[55];
    double x[55],y[55],a[55],b[55],d,ans=0,d1,ans1=1e16,xx,yy;
    bool line=true;
    cin >> n;
    for(i=1;i<=n;i++){
        cin >> xm[i] >> ym[i];
        x[i]=(double)xm[i];
        y[i]=(double)ym[i];
    }
    if(n==2){
        d=(x[1]-x[2])*(x[1]-x[2])+(y[1]-y[2])*(y[1]-y[2]);
        d=sqrt(d);
        d/=2.0;
        cout << d << endl;
        return 0;
    }
    for(i=2;i<=n;i++){
        ll g;
        xm[i]-=xm[1]; ym[i]-=ym[1];
        if(xm[i]<0){
            xm[i]=-xm[i];
            ym[i]=-ym[i];
        }
        g=gcd(xm[i],ym[i]);
        xm[i]/=g; ym[i]/=g;
        if(i!=2) if(xm[i]!=xm[i-1]||ym[i]!=ym[i-1]) line=false;
    }
    for(i=1;i<=n;i++){
        for(j=i+1;j<=n;j++){
            bool test=true;
            d=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
            d=sqrt(d); d/=2.0;
            xx=(x[i]+x[j])/2.0; yy=(y[i]+y[j])/2.0;
            for(k=1;k<=n;k++){
                d1=(x[k]-xx)*(x[k]-xx)+(y[k]-yy)*(y[k]-yy);
                d1=sqrt(d1);
                if(d1>d) test=false;
            }
            if(test){
                ans1=min(ans1,d);
            }
        }
    }
    for(i=1;i<=n;i++){
        polygon pol;
        for(j=1;j<=n;j++){
            if(i==j) continue;
            a[j]=x[j]; b[j]=y[j];
            a[j]-=x[i]; b[j]-=y[i];
            d=a[j]*a[j]+b[j]*b[j];
            a[j]*=(1e16/d);
            b[j]*=(1e16/d);
            point pm(a[j],b[j]);
            pol.push_back(pm);
        }
        for(j=1;j<=n;j++){
            for(k=j+1;k<=n;k++){
                bool ok=true;
                if(j==i||k==i) continue;
                point pm1(a[j],b[j]);
                point pm2(a[k],b[k]);
                L l1(pm1,pm2);
                for(l=1;l<=n;l++){
                    if(l==i||l==j||l==k) continue;
                    point pm3(0,0);
                    point pm4(a[l],b[l]);
                    L l2(pm3,pm4);
                    bool test=intersectLS(l1,l2);
                    if(!test) ok=false;
                    l2.clear();
                }
                if(ok){
                    point pm5(0,0);
                    d=distanceLP(l1,pm5);
                    ans=max(ans,d);
                }
                l1.clear();
            }
        }
    }
    ans=1e16/(ans*2);
    ans=min(ans,ans1);
    if(line) cout << setprecision(10) << ans1 << endl;
    else cout << setprecision(10) << ans << endl;
    return 0;
}


Measured memory_bytes: 256