#include <bits/stdc++.h>
#include <iostream>
#include <ctime>
using namespace std;
#define _LL long long
#define rep(i, n) for (_LL i = 0; i < (_LL)(n); i++)
#define vecrep(itr, v) for (auto itr = (v).begin(); itr != (v).end(); itr++)


struct V2 
{
    double x;
    double y;

    V2() { x = 0; y = 0; }
    V2(double tx, double ty) { x = tx; y = ty;}
    V2(const V2 &t) { x = t.x; y = t.y; }
    V2& operator += ( const V2 &t ) { x += t.x; y += t.y; return (*this); }
    const V2 operator + (V2 &t)  const { V2 ans(*this); return ans += t; }       
    V2& operator -= ( const V2 &t ) { x -= t.x; y -= t.y; return (*this); }
    const V2 operator - (V2 &t)  const { V2 ans(*this); return ans -= t; }       
    V2& operator *= ( double k ) { x *= k; y *= k; return (*this); }
    V2& operator /= ( double k ) { x /= k; y /= k; return (*this); }
    double length() const { return sqrt(x * x + y * y); }
    double square() const { return x * x + y * y; }
    static V2 fromcin() { double x, y; cin >> x >> y; return V2(x, y);}
};

// 平面上の直線
struct VLINE
{
    // ax + by + c = 0
    double a;
    double b;
    double c;

    void normalize() { if(valid()) { double d = sqrt(a * a + b * b); a /= d; b /= d; c /= d;} }
    VLINE() { a = 0; b = 0; c = 0; }
    VLINE(double _a, double _b, double _c) { a = _a; b = _b; c = _c; normalize();}
    VLINE(const VLINE &t) { a = t.a; b = t.b; c = t.c; normalize();}
    // 二点を通る直線
    VLINE(V2 &s, V2 &t)
    {
        if(s.y != t.y){ a = 1; b = -(t.x - s.x) / (t.y - s.y); c = -a * s.x - b * s.y; }
        else if (s.x != t.x) { a = 0; b = 1; c = -t.y; }
        else { a = 0; b = 0; c = 0; }
        normalize();
    }
    // y = mx + k
    VLINE(double m, double k) { a = m; b = -1; c = k; normalize(); }

    bool valid() { return (a != 0 || b != 0); }

    double getDistance(V2 &p) const { return abs(a * p.x + b * p.y + c); }

    // pを通る半径円との交点を求める。交点があればtrue
    bool intersectionCircle(V2 &p, double r, V2 &ans1, V2 &ans2) const 
    {
        double D = getDistance(p);
        double s = sqrt(r * r - D * D);
        if( D > r ) return false;
        ans1.x = a * D - b * s + p.x; ans1.y = b * D + a * s + p.y;
        ans2.x = a * D + b * s + p.x; ans2.y = b * D - a * s + p.y;
        return true;
    }

    // 平行かどうか
    static bool isParallel(VLINE &l1, VLINE &l2)
    {
        if( l1.a * l1.b == 0 ) return (l1.a == 0 && l2.a == 0) || (l1.b == 0 && l2.b == 0);
        return l1.a * l2.b == l1.b * l2.a;
    }

    // 二直線の交点(平行でないことを確認してから呼び出す)
    static V2 intersection(VLINE &l1, VLINE &l2)
    {
        double y = (l1.a * l2.c - l2.a * l1.c) / (l2.a * l1.b - l1.a * l2.b);
        double x = ( ( l1.a != 0 ) ? -(l1.b * y + l1.c) / l1.a : -(l2.b * y + l2.c) / l2.a );
        return V2(x, y);
    }

    // 二つの円の交点を通る直線を返す(交点がない場合でも結果を返す)
    static VLINE getCircleIntersectionLine(V2 &p1, double r1, V2 &p2, double r2)
    {
        double a = 2 * (p2.x - p1.x);
        double b = 2 * (p2.y - p1.y);
        double c = (p1.x + p2.x) * (p1.x - p2.x) + (p1.y + p2.y) * (p1.y - p2.y) + (r2 + r1) * (r2 - r1);
        return VLINE(a, b, c);
    }

    //垂直二等分線
    static VLINE verticalBisector(V2 &p1, V2 &p2)
    {
        return VLINE(2 * (p2.x - p1.x), 2 * (p2.y - p1.y), (p1.x + p2.x) * (p1.x - p2.x) + (p1.y + p2.y) * (p1.y - p2.y));
    }

    // 二つの円の交点を返す(交点がない場合でも結果を返す)
    static bool twoCircleIntersection(V2 &p1, double r1, V2 &p2, double r2, V2 &ans1, V2 &ans2)
    {
        VLINE line = getCircleIntersectionLine(p1, r1, p2, r2);
        return line.intersectionCircle(p1, r1, ans1, ans2);
    }
};

bool checksub(double r2, V2 &p1, V2 *p, int n)
{
    rep(i, n)
    {
        if( (p[i] - p1).square() - r2 > 0.0000001 ) return false;
    }
    return true;
}

bool check(double r, V2 *p, int n)
{
    double r2 = r * r;
    rep(i, n - 1)
        for( int j = i + 1; j < n; j++) 
        {
            V2 p1, p2;
            if( !VLINE::twoCircleIntersection(p[i], r, p[j], r, p1, p2) ) return false;
            if( checksub( r2, p1, p, n) ) return true;
            if( checksub( r2, p2, p, n) ) return true;
        }

    return false;
}

int main()
{
    int n;
    cin >> n;
    V2 *p = new V2[n];
    rep(i, n) p[i] = V2::fromcin();
    double longest = 0;
    rep(i, n - 1)
        for( int j = i + 1; j < n; j++) longest = max(longest, (p[i] - p[j]).length());

    double minr = longest / 2;
    double maxr = longest;

    while( maxr - minr > 0.00000001 )
    {
        double r = (minr + maxr) * 0.5;
        if( check(r, p, n) )
        {
            maxr = r;
        }
        else
        {
            minr = r;
        }
    }
    cout << std::fixed << std::setprecision(10) << minr;
    
    return 0;    
}

Measured memory_bytes: 3832