#include<bits/stdc++.h>
using namespace std;
const double eps=1e-8;
int cmp(double x)
{
    if(fabs(x)<eps)return 0;
    if(x>0)return 1;
    return -1;
}
int cmp(double x,double y)
{
    return cmp(x-y);
}
inline double sqr(double x)
{
    return x*x;
}
struct point
{
    double x,y;
    point() {} point(double a,double b):x(a),y(b) {} friend point operator +(const point &a,const point &b)
    {
        return point(a.x+b.x,a.y+b.y);
    } friend point operator -(const point &a,const point &b)
    {
        return point(a.x-b.x,a.y-b.y);
    } friend bool operator ==(const point &a,const point &b)
    {
        return cmp(a.x-b.x)==0 && cmp(a.y-b.y)==0;
    } friend bool operator <(const point &a,const point &b)
    {
        if(cmp(a.x-b.x)<0)return true;
        if(cmp(a.x-b.x)>0)return false;
        return cmp(a.y-b.y)<0;
    } friend point operator *(const point &a,const double &b)
    {
        return point(a.x*b,a.y*b);
    } friend point operator *(const double &a,const point &b)
    {
        return point(a*b.x,a*b.y);
    } friend point operator /(const point &a,const double &b)
    {
        return point(a.x/b,a.y/b);
    } friend istream& operator>>(istream &fin,point&a)
    {
        fin>>a.x>>a.y;
        return fin;
    } double norm()//模
    {
        return sqrt(sqr(x)+sqr(y));
    }
};
double det(const point &a,const point &b)//叉积
{
    return a.x*b.y-a.y*b.x;
}
double dot(const point &a,const point &b)//点积
{
    return a.x*b.x+a.y*b.y;
}
double dist(const point &a,const point &b)//两点距离
{
    return (a-b).norm();
}
point rorate_point(const point &p,double A)//op绕远点逆时针旋转A（弧度）
{
    double tx=p.x,ty=p.y;
    return point(tx*cos(A)-ty*sin(A),tx*sin(A)+ty*cos(A));
}
struct line
{
    point a,b;
    line(point x,point y):a(x),b(y) {} };
double dis_point_segment(const point p,const point s,const point t)//求点p到线段st的距离
{
    if(cmp(dot(p-s,t-s))<0)return (p-s).norm();
    if(cmp(dot(p-t,s-t))<0)return (p-t).norm();
    return fabs(det(s-p,t-p)/dist(s,t));
}
void PointProjLine(const point p,const point s,const point t,point &cp)//求p到st的垂足，保存在cp中
{
    double r=dot((t-s),(p-s))/dot(t-s,t-s);
    cp=s+r*(t-s);
}
bool PointOnSegment(point p,point s,point t)//p是否在st上，包括端点
{
    return cmp(det(p-s,t-s))==0 && cmp(dot(p-s,p-t))<=0;
}
bool parallel(line a,line b)//线ab是否平行
{
    return !cmp(det(a.a-a.b,b.a-b.b));
}
bool line_make_point(line a,line b,point &res)//判断直线ab是否相交，若相交在res中保存交点，如果需要判断线段相交需先调用intersect函数确认
{
    if(parallel(a,b)) return false;
    double s1=det(a.a-b.a,b.b-b.a);
    double s2=det(a.b-b.a,b.b-b.a);
    res=(s1*a.b-s2*a.a)/(s1-s2);
    return true;
}
double multiply(point sp,point ep,point op)
{
    return((sp.x-op.x)*(ep.y-op.y)-(ep.x-op.x)*(sp.y-op.y));
}
bool intersect(line u,line v)//判断线段是否相交
{
    return( (max(u.a.x,u.b.x)>=min(v.a.x,v.b.x))&& //排斥实验
            (max(v.a.x,v.b.x)>=min(u.a.x,u.b.x))&& (max(u.a.y,u.b.y)>=min(v.a.y,v.b.y))&& (max(v.a.y,v.b.y)>=min(u.a.y,u.b.y))&& (multiply(v.a,u.b,u.a)*multiply(u.b,v.b,u.a)>=0)&& //跨立实验
            (multiply(u.a,v.b,v.a)*multiply(v.b,u.b,v.a)>=0));
}
const int maxn=10001;
struct polygon
{
    int n;
    point a[maxn];
    double perimeter()//周长
    {
        double sum=0;
        a[n]=a[0];
        for(int i=0; i<n; i++)sum+=(a[i+1]-a[i]).norm();
        return sum;
    } double area()//面积
    {
        double sum=0;
        a[n]=a[0];
        for(int i=0; i<n; i++)sum+=det(a[i+1],a[i]);
        return sum/2.;
    } int Point_In(point t)//点t与多边形的关系 2在边上1在里面0在外面
    {
        int num=0,i,d1,d2,k;
        a[n]=a[0];
        for(int i=0; i<n; i++)
        {
            if(PointOnSegment(t,a[i],a[i+1]))return 2;
            k=cmp(det(a[i+1]-a[i],t-a[i]));
            d1=cmp(a[i].y-t.y);
            d2=cmp(a[i+1].y-t.y);
            if(k>0 && d1<=0 && d2>0)num++;
            if(k<0 && d2<=0 && d1>0)num++;
        }
        return num & 1;
    }
};
struct polygon_convex//凸包
{
    vector<point> P;
    polygon_convex(int Size=0)
    {
        P.resize(Size);
    }
};
bool comp_less(const point &a,const point &b)
{
    return cmp(a.x-b.x)<0|| cmp(a.x-b.x)==0 && cmp(a.y-b.y)<0;
}
polygon_convex convex_hull(vector<point> a)//用点集a生成凸包,逆时针顺序
{
    polygon_convex res(2*a.size()+5);
    sort(a.begin(),a.end(),comp_less);
    a.erase(unique(a.begin(),a.end()),a.end());
    int m=0;
    for(int i=0; i<a.size(); ++i)
    {
        while(m>1 && cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<=0) --m;
        res.P[m++]=a[i];
    }
    int k=m;
    for(int i=int(a.size())-2; i>=0; --i)
    {
        while(m>k&&cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<=0)--m;
        res.P[m++]=a[i];
    }
    res.P.resize(m);
    if(a.size()>1) res.P.resize(m-1);
    return res;
}
int containOlogn(const polygon_convex &a,const point &b)//判断点是否在凸包内，log级别
{
    int n=a.P.size();
    point g=(a.P[0]+a.P[n/3]+a.P[2*n/3])/3.0;
    int l=0,r=n;
    while(l+1<r)
    {
        int mid=(l+r)/2;
        if(cmp(det(a.P[l]-g,a.P[mid]-g))>0)
        {
            if(cmp(det(a.P[l]-g,b-g))>=0 && cmp(det(a.P[mid]-g,b-g))<0) r=mid;
            else l=mid;
        }
        else
        {
            if(cmp(det(a.P[l]-g,b-g))<0 && cmp(det(a.P[mid]-g,b-g))>=0) l=mid;
            else r=mid;
        }
    }
    r%=n;
    int z=cmp(det(a.P[r]-b,a.P[l]-b))-1;
    if(z==-2)return 1;
    return z;
}
bool containOn(const polygon_convex &a,const point &b)//判断点是否在凸包内 On级别 实际上一般远远不到这个值
{
    int n=a.P.size();
#define next(i) ((i+1)%n)
       int sign=0;
    for(int i=0; i<n; ++i)
    {
        int x=cmp(det(a.P[i]-b,a.P[next(i)]-b));
        if(x)
        {
            if(sign)
            {
                if(sign!=x) return false;
            }
            else sign=x;
        }
    }
    return true;
}
bool inaline(line a,line b)
{
    if(!parallel(a,b)) return false;
    if(cmp(det(a.a-a.b,a.a-b.a))==0) return true;
    return false;
}
typedef pair<point,point> Halfplane;
const double INF=10000;
double arg(const point& p)
{
    return atan2(p.y,p.x);
}
inline double satisfy(point a,Halfplane p)
{
    return cmp(det(a-p.first,p.second-p.first))<=0;
}
point crosspoint(const Halfplane &a,const Halfplane &b)
{
    double k=det(b.first-b.second,a.first-b.second);
    k=k/(k-det(b.first-b.second,a.second-b.second));
    return a.first+(a.second-a.first)*k;
}
bool cmpp(const Halfplane &a,const Halfplane &b)
{
    int res=cmp(arg(a.second-a.first)-arg(b.second-b.first));
    return res==0?satisfy(a.first,b):res<0;
}
vector<point> HalfplaneIntersection(vector<Halfplane>v)//半平面交
{
    sort(v.begin(),v.end(),cmpp);
    deque<Halfplane>q;
    deque<point>ans;
    q.push_back(v[0]);
    for(int i=1; i<v.size(); ++i)
    {
        if(cmp(arg(v[i].second-v[i].first)-arg(v[i-1].second-v[i-1].first))==0)
        {
            continue;
        }
        while(ans.size()>0&&!satisfy(ans.back(),v[i]))
        {
            ans.pop_back();
            q.pop_back();
        }
        while(ans.size()>0&&!satisfy(ans.front(),v[i]))
        {
            ans.pop_front();
            q.pop_front();
        }
        ans.push_back(crosspoint(q.back(),v[i]));
        q.push_back(v[i]);
    }
    while(ans.size()>0&&!satisfy(ans.back(),q.front()))
    {
        ans.pop_back();
        q.pop_back();
    }
    while(ans.size()>0&&!satisfy(ans.front(),q.back()))
    {
        ans.pop_front();
        q.pop_front();
    }
    ans.push_back(crosspoint(q.back(),q.front()));
    return vector<point>(ans.begin(),ans.end());
}
typedef vector<point>Convex;
Convex convexIntersection(Convex v1,Convex v2) //凸多边形求交
{
    vector<Halfplane>h;
    for(int i=0; i<v1.size(); ++i) h.push_back(Halfplane(v1[i],v1[(i+1)%v1.size()]));
    for(int i=0; i<v2.size(); ++i) h.push_back(Halfplane(v2[i],v2[(i+1)%v2.size()]));
    return HalfplaneIntersection(h);
}

void circle_center(point p0,point p1,point p2,point&cp)
{
    double a1 = p1.x-p0.x,b1=p1.y-p0.y,c1=(a1*a1+b1*b1)/2;
    double a2 = p2.x-p0.x,b2=p2.y-p0.y,c2=(a2*a2+b2*b2)/2;
    double d = a1*b2-a2*b1;
    cp.x=p0.x+(c1*b2-c2*b1)/d;
    cp.y=p0.y+(a1*c2-a2*c1)/d;
}

void circle_center(point p0,point p1,point&cp)
{
    cp.x=(p0.x+p1.x)/2;
    cp.y=(p0.y+p1.y)/2;
}
point center;
double radius;

bool point_in(const point&p)
{
    return cmp((p-center).norm()-radius)<0;
}

void min_circle_cover(point a[],int n)
{
    radius = 0;
    center = a[0];
    for(int i=1;i<n;++i)if(!point_in(a[i]))
    {
        center = a[i];
        radius = 0;
        for(int j=0;j<i;++j)if(!point_in(a[j]))
        {
            circle_center(a[i],a[j],center);
            radius=(a[j]-center).norm();
            for(int k=0;k<j;++k)if(!point_in(a[k]))
            {
                circle_center(a[i],a[j],a[k],center);
                radius = (a[k]-center).norm();
            }
        }
    }
}
int n;
point p[55];
int main()
{
    cin>>n;
    for(int i=0;i<n;++i)cin>>p[i];
    min_circle_cover(p,n);
    printf("%.10f\n",radius);
}

Measured memory_bytes: 256