#include<bits/stdc++.h>

double PI = acos(-1);
double eps=1e-9;
struct Coordinate_Plane{
    double x,y;
    Coordinate_Plane(double X=0,double Y=0):x(X),y(Y){}
    Coordinate_Plane(const Coordinate_Plane &cp){
        x=cp.x;y=cp.y;
    }
    Coordinate_Plane& set(double X,double Y){
        x=X;y=Y;
        return *this;
    }
    Coordinate_Plane& operator=(const Coordinate_Plane &p){return set(p.x , p.y);}
    Coordinate_Plane operator+(const Coordinate_Plane &p)const{return Coordinate_Plane(x+p.x , y+p.y);}
    Coordinate_Plane operator-(const Coordinate_Plane &p)const{return Coordinate_Plane(x-p.x , y-p.y);}
    Coordinate_Plane operator*(double s)const{return Coordinate_Plane(x*s,y*s);}
    Coordinate_Plane operator/(double s)const{return Coordinate_Plane(x/s,y/s);}
    friend Coordinate_Plane operator*(double s,const Coordinate_Plane &r){return Coordinate_Plane(r.x*s,r.y*s);}
    friend Coordinate_Plane operator/(double s,const Coordinate_Plane &r){return Coordinate_Plane(r.x/s,r.y/s);}
    double operator*(Coordinate_Plane p)const{return dot(p);}
    double operator^(Coordinate_Plane p)const{return cross(p);}
    Coordinate_Plane& operator+=(const Coordinate_Plane &p){return set(x+p.x , y+p.y);}
    Coordinate_Plane& operator-=(const Coordinate_Plane &p){return set(x-p.x , y-p.y);}
    Coordinate_Plane& operator*=(double s){return set(x*s,y*s);}
    Coordinate_Plane& operator/=(double s){return set(x/s,y/s);}
    double dot(const Coordinate_Plane &p)const{return x*p.x + y*p.y;} 
    double cross(const Coordinate_Plane &p)const{return x*p.y-p.x*y;}
    int ort()const{
        if(fabs(x)<eps && fabs(y)<eps) return 0;
        if(y>0) return (x>0)?1:2;
        else return (x<=0)?3:4;
    }
    bool operator<(const Coordinate_Plane &p)const{
        int o=ort(),po=p.ort();
        if(o!=po) return o<po;
        else{
            double cr=cross(p);
            if(cr==0){
                double d=norm(),pd=p.norm();
                return d<pd;
            }
            return cr>0;
        }
    }
    friend std::istream& operator>>(std::istream &is, Coordinate_Plane &x){double valX,valY; is>>valX>>valY; x.set(valX,valY); return is;}
    friend std::ostream& operator<<(std::ostream &os, const Coordinate_Plane &v){ printf("%.6f %.6f",v.x,v.y); return os; }
    double norm2()const{return x*x+y*y;}
    double norm()const{return sqrt(norm2());}
    double rad()const{
        if(x==0){
            if(y>0) return PI/2.0;
            if(y==0) return -1.0;
            if(y<0) return -PI/2.0;
        }else{
            if(y==0){
                if(x<0) return PI;
                if(x>0) return 0.0;
            }
            else return atan2(y,x);
        }
    }
    void rotate(double theta){
        double X=x,Y=y;
        x=cos(theta)*X-sin(theta)*Y;
        y=sin(theta)*X+cos(theta)*Y;
    }
};

struct Circle{
    Coordinate_Plane center;
    double radius;
    Circle(double r=0,Coordinate_Plane c={0,0}):radius(r),center(c){}
    bool inside(const Coordinate_Plane &C)const{
        return (C-center).norm2()<radius*radius+eps;
    }
    bool intersect(const Circle &C)const{
        return (C.center-center).norm2()<(C.radius+radius)*(C.radius+radius)+eps;
    }
    std::pair<Coordinate_Plane,Coordinate_Plane> interP(const Circle &C)const{
        Coordinate_Plane Q=center-C.center;
        double x1=Q.x,y1=Q.y,r1=radius,r2=C.radius;
        double a=(x1*x1+y1*y1+r1*r1-r2*r2)/2.0,t=Q.norm2();
        Coordinate_Plane A((a*x1+y1*sqrt(t*r1*r1-a*a))/t,(a*y1-x1*sqrt(t*r1*r1-a*a))/t);
        Coordinate_Plane B((a*x1-y1*sqrt(t*r1*r1-a*a))/t,(a*y1+x1*sqrt(t*r1*r1-a*a))/t);
        A+=C.center;
        B+=C.center;
        return std::make_pair(A,B);
    }
    friend std::ostream& operator<<(std::ostream &os, const Circle &v){ os << v.center<<" ";printf("%.06f",v.radius); return os; }
};

int main(){
    int N;
    std::cin>>N;
    std::vector<Coordinate_Plane> P(N);
    for(int i=0;i<N;++i) std::cin>>P[i];
    double l=0,r=1e3;
    while(r-l>1e-9){
        double mid=(l+r)/2.0;
        std::vector<Circle> C;
        for(int i=0;i<N;++i){
            Circle A(mid,P[i]);
            for(int j=i+1;j<N;++j){
                Circle B(mid,P[j]);
                if(A.intersect(B)){
                    std::pair<Coordinate_Plane,Coordinate_Plane> tmp=A.interP(B);
                    C.push_back(Circle(mid,tmp.first));
                    C.push_back(Circle(mid,tmp.second));
                }
            }
        }
        bool judge=false;
        for(int i=0;i<C.size();++i){
            bool ok=true;
            for(int j=0;j<N;++j){
                if(!C[i].inside(P[j])){
                    ok=false;
                }
            }
            if(ok) judge=true;
        }
        if(judge) r=mid;
        else l=mid;
    }
    printf("%.16f\n",r);
}

Measured memory_bytes: 460