#include <bits/stdc++.h>
using namespace std;
#define __ <<" "<<
#define ___ <<" "
#define bash push_back
#define ALL(x) x.begin(),x.end()
// #define int long long
struct IoSetup {
    IoSetup() {
        cin.tie(0);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(10);
        cerr << fixed << setprecision(10);
    }
}IoSetup;

using Int = __int128_t;
using ll = long long;
using pii = pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int SMOD = 1000000007;
constexpr int NMOD = 998244353;
constexpr int dx[]={1,0,-1,0,1,1,-1,-1};
constexpr int dy[]={0,-1,0,1,-1,1,-1,1};

inline bool inside(int x,int y,int w,int h){return (x>=0 && y>=0 && x<w && y<h);}
template<class T>bool chmax(T &a, const T&b){if(a<b)return(a=b,1);return 0;}
template<class T>bool chmin(T &a, const T&b){if(b<a)return(a=b,1);return 0;}


#define EPS (1e-10)
#define eq(a,b) (fabs((a)-(b))<EPS)

class Point{
    public:
    double x,y;
    Point(double x=0.0,double y=0.0):x(x),y(y){}
    
    const Point operator + (const Point& p) const {return(Point(this->x+p.x,this->y+p.y));}
    const Point operator - (const Point& p) const {return(Point(this->x-p.x,this->y-p.y));}
    const Point operator * (const double a) const {return(Point(a*x,a*y));}
    const Point operator / (const double a) const {return(Point(x/a,y/a));}
    
    const double abs() const {return(sqrt(norm()));}
    const double norm() const {return(x*x+y*y);}
    
    bool operator < (const Point &p) const{
        return (eq(x,p.x)?y<p.y:x<p.x);
    }
    bool operator > (const Point &p) const{
        return (eq(x,p.x)?y>p.y:x>p.x);
    }
    bool operator == (const Point &p) const{
        return (eq(x,p.x)&&eq(y,p.y));
    }
};

using Vector = Point;
using Polygon = vector<Point>;
struct Segment {
    Point p1, p2;
};
using Line = Segment;

// 内積
double dot(Point a,Point b){
    return (a.x*b.x+a.y*b.y);
}
// 外積
double cross(Point a,Point b){
    return (a.x*b.y-a.y*b.x);
}
// 直交
bool isOrthogonal ( Vector a, Vector b ) {
    return eq ( dot ( a, b ), 0.0 );
}
bool isOrthogonal ( Segment a, Segment b ) {
    return eq( dot ( a.p2 - a.p1, b.p2 - b.p1 ), 0.0 );
}

// 平行
bool isParallel ( Vector a, Vector b ) {
    return eq ( cross( a, b ), 0.0 );
}
bool isParallel ( Segment a, Segment b ) {
    return eq ( cross ( a.p2 - a.p1, b.p2 - b.p1 ), 0.0 );
}

// 射影
Point project ( Segment s, Point p ) {
    Vector base = s.p2 - s.p1;
    double r = dot ( p - s.p1, base ) / base.norm();
    return s.p1 + base * r;
}



/* Smallest Enclosing Circle */
template<typename iter>
pair<Point, double> min_ball(iter left, iter right, int seed = 1821) {
    const int n = right - left;
    if(n == 1) return {*left, (double)0};

    mt19937 mt(seed);
    shuffle(left, right, mt);

    iter ps = left;
    using Circle = pair<Point, double>;

    auto make_circle_3 = [](const Point&a, const Point&b, const Point&c) -> Circle {
        double A = (b - c).norm(), B = (c - a).norm(), C = (a - b).norm(), S = cross(b - a, c - a);
        Point p = (a * A * (B + C - A) + b * B * (C + A - B) + c * C * (A + B - C)) / (4 * S * S);
        double r2 = (p - a).norm();
        return {p, r2};
    };
    auto make_circle_2 = [](const Point&a, const Point&b) -> Circle {
        Point c = (a + b) / (double)(2);
        double r2 = (a - c).norm();
        return {c, r2};
    };
    auto in_circle = [](const Point&a, const Circle&c) -> bool {
        return (a - c.first).norm() <= c.second + EPS;
    };

    Circle c = make_circle_2(ps[0], ps[1]);

    for(int i = 2; i < n; i++) {
        if(!in_circle(ps[i], c)) {
            c = make_circle_2(ps[0], ps[i]);
            for(int j = 1; j < i; j++) {
                if(!in_circle(ps[j], c)) {
                    c = make_circle_2(ps[i], ps[j]);
                    for(int k = 0; k < j; k++) {
                        if(!in_circle(ps[k], c)) {
                            c = make_circle_3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}

signed main() {

    int n;
    cin >> n;

    Polygon p;

    for(int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        p.bash(Point(x, y));
    }

    auto ret = min_ball(ALL(p));

    cout << sqrt(ret.second) << endl;

    return 0;
}

Measured memory_bytes: 3832