#include "bits/stdc++.h"
using namespace std;
#define Rep(i,n) for(int i=0;i<(int)(n);i++)
#define For(i,n1,n2) for(int i=(int)(n1);i<(int)(n2);i++)
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define RREP(i,n) for(ll i=((ll)(n)-1);i>=0;i--)
#define FOR(i,n1,n2) for(ll i=(ll)(n1);i<(ll)(n2);i++)
#define RFOR(i,n1,n2) for(ll i=((ll)(n1)-1);i>=(ll)(n2);i--)
#define all(a)  (a).begin(),(a).end()
#define SORT(a) sort((a).begin(),(a).end())
#define oorret 0
#define oor(x) [&](){try{x;} catch(const out_of_range& oor){return oorret;} return x;}()
#define IOS cin.tie(0),ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<ll, ll> P;
template<typename T1, typename T2> inline bool chmin(T1& a, T2 b) { if (a > b) { a = b; return 1; }return 0; }
template<typename T1, typename T2> inline bool chmax(T1& a, T2 b) { if (a < b) { a = b; return 1; }return 0; }
template<class Type>struct is_vector : std::false_type {};
template<class ValueType, class Alloc>struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T> inline std::ostream& operator << (std::ostream& out, const std::vector<T>& v) {
    if (v.empty())return out;
    constexpr bool is_vector_v = is_vector<T>::value;
    if (is_vector_v)for (auto itr = v.begin(); itr != v.end();)out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
    else for (auto itr = v.begin(); itr != v.end();)out << (*itr), out << ((++itr != v.end()) ? " " : "");
    return out;
}
inline void put() {}
template<class T> inline void put(const T& first) { std::cout << first << "\n"; }
template<class T, class... N> inline void put(const T& first, const N& ... rest) { std::cout << first << " "; put(rest...); }
inline void putn() {}
template<class T, class... N> inline void putn(const T& first, const N& ... rest) { std::cout << first << "\n"; putn(rest...); }

template<typename T>class point{
public:
    T x,y;
    point(T x,T y):x(x),y(y){}
    point():x(0),y(0){}
    void set(T x,T y){
        this->x = x;
        this->y = y;
    }
    T p2dist(point p){
        T dx = x-p.x;
        T dy = y-p.y;
        return dx*dx+dy*dy;
    }
    T dist(point p){
        return sqrt(p2dist(p));
    }
    T dist(T x,T y){
        return dist(point(x,y));
    }
    T inner_product(point p){ // this・p
        return x*p.x+y*p.y;
    }
    T outer_product(point p){ // this × p
        return x*p.y-y*p.x;
    }
    T cos(point p1,point p2){ // 角度p1,this,p2の余弦
        point t1 = p1-(*this),t2 = p2-(*this);
        T ip = t1.inner_product(t2);
        return ip/t1.size()/t2.size();
    }
    T sin(point p1,point p2){ // 角度p1,this,p2の正弦
        point t1 = p1-(*this),t2 = p2-(*this);
        T ip = t1.outer_product(t2);
        return ip/t1.size()/t2.size();
    }
    T size(){
        return sqrt(x*x+y*y);
    }
    point norm(){
        return (*this)/size();
    }
    point project(point p1,point p2){ // p1,p2を通る直線へ下ろした垂線の足
        point p3 = p2-p1;
        T s = p1.p2dist(p2);
        T t = (*this-p1)*p3/s;
        point res = p3*t;
        res+=p1;
        return res;
    }
    T line_dist(point p1,point p2){ // p1,p2を通る直線との距離
        point proj = this->project(p1, p2);
        return this->dist(proj);
    }
    point operator+(point p){return point(x+p.x,y+p.y);}
    point operator-(point p){return point(x-p.x,y-p.y);}
    point operator*(T t){return point(x*t,y*t);}
    T operator*(point p){return inner_product(p);}
    point operator/(T t){return point(x/t,y/t);}
    void operator+=(point p){x+=p.x;y+=p.y;}
    void operator-=(point p){x-=p.x;y-=p.y;}
    void operator*=(T t){x*=t;y*=t;}
    void operator/=(T t){x/=t;y/=t;}
};

template<typename T>
class triangle{
public:
    point<T> p1,p2,p3;
    array<point<T>,3> p;
    triangle(point<T> p1,point<T> p2,point<T> p3):p1(p1),p2(p2),p3(p3){
        p[0] = p1;
        p[1] = p2;
        p[2] = p3;
    }
    void set(point<T> p1,point<T> p2,point<T> p3){
        this->p1 = p1;
        this->p2 = p2;
        this->p3 = p3;
        p[0] = p1;
        p[1] = p2;
        p[2] = p3;
    }
    T area(){
        point<T> t1 = p[1]-p[0],t2 = p[2]-p[0];
        T res = t1.outer_product(t2);
        res = abs(res);
        return res;
    }
    int obtuse(){ // 鈍角の頂点番号を返す(0-indexed)、鋭角三角形の場合-1
        for(int i=0;i<3;++i){
            point<T> t1 = p[(1+i)%3]-p[i], t2 = p[(2+i)%3]-p[i];
            T ip = t1*t2;
            if(ip<0){
                return i;
            }
        }
        return -1;
    }
    int right(T eps=1e-9){ // 直角の頂点番号を返す(0-indexed)、鋭角三角形の場合-1
        for(int i=0;i<3;++i){
            point<T> t1 = p[(1+i)%3]-p[i], t2 = p[(2+i)%3]-p[i];
            T ip = t1*t2;
            if(abs(ip)<eps){
                return i;
            }
        }
        return -1;
    }
    point<T> gravity_center(){ // 重心
        point<T> res = p[0]+p[1]+p[2];
        res /= 3;
        return res;
    }
    point<T> inner_center(){ // 内心
        point<T> res;
        T d1,d2,d3;
        d1 = p[1].dist(p[2]);
        d2 = p[2].dist(p[0]);
        d3 = p[0].dist(p[1]);
        res = p[0]*d1+p[1]*d2+p[2]*d3;
        res/=d1+d2+d3;
        return res;
    }
    T inscribed_circle_diameter(){ // 内接円の半径
        point<T> ic = inner_center();
        T res = ic.line_dist(p[0], p[1]);
        return res;
    }
    point<T> circumcenter(){ // 外心
        point<T> res;
        T s1,s2,s3;
        s1 = 2*p[0].sin(p[1], p[2])*p[0].cos(p[1],p[2]);
        s2 = 2*p[1].sin(p[2], p[0])*p[1].cos(p[2],p[0]);
        s3 = 2*p[2].sin(p[0], p[1])*p[2].cos(p[0],p[1]);;
        res = p[0]*s1+p[1]*s2+p[2]*s3;
        res/= s1+s2+s3;
        return res;
    }
    T circumradius(){ // 外接円の半径
        point<T> cc = circumcenter();
        T res = cc.dist(p[0]);
        return res;
    }
    point<T> orthocenter(){ // 垂心(verifyしてない)
        point<T> res;
        T icd = inscribed_circle_diameter();
        T c = p[0].cos(p[1],p[2]);
        point<T> d = p[0].project(p[1],p[2]);
        point<T> ah = d.norm()*icd*c*2;
        res = p[0]+ah;
        return res;
    }
};

using po = point<double>;
using tri = triangle<double>;

double radius(vector<po>& p,po p2){
    double res = 0;
    REP(i,p.size()){
        chmax(res,p2.dist(p[i]));
    }
    return res;
}

int main(){
    //using point = point<double>;
    //using triangle = triangle<double>;
    double eps = 1e-9;
    int n;
    cin >> n;
    vector<double> x(n),y(n);
    vector<po> p(n);
    REP(i,n){
        cin >> x[i] >> y[i];
        p[i] = po(x[i],y[i]);
    }
    if(n==2){
        double res = p[0].dist(p[1])/2;
        cout << setprecision(20) << res << endl;
        return 0;
    }
    double res=2e6;
    REP(i,n){
        REP(j,n){
            REP(k,n){
                if(i!=j&&j!=k&&k!=i){
                    tri tri(p[i],p[j],p[k]);
                    REP(l,3){
                        po p1 = tri.p[l]+tri.p[(l+1)%3];
                        p1/=2;
                        chmin(res,radius(p,p1));
                    }
                    if(tri.obtuse()<0){
                        po p2 = tri.circumcenter();
                        chmin(res,radius(p,p2));
                    }
                }
            }
        }
    }
    cout << setprecision(20) << res << endl;
    return 0;
}


Measured memory_bytes: 256