#include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, m, n) for (ll i = m; i < n; i++)
#define repr(i, m, n) for (ll i = m; i >= n; i--)
#define de(x) cout << #x << "=" << x << endl;
template <class T> bool maxi(T &a, const T &b) {
    if (a < b) { a = b; return 1;} return 0;}
template <class T> bool mini(T &a, const T &b) {
    if (b < a) { a = b; return 1;} return 0;}
#define dame {cout<< "Yes" <<"\n"; return;}
#define INF2 1000000000000000037
#define INF  1000000007
#define MOD  1000000007
using namespace std;
using ll = long long;
using ld = long double;
using P  = pair<ll,ll>;
//--GLOBAL--------------------------------- 
const ld INFL=1LL<<60;
const ld EPS=1e-9;
const ld PI=acosl(-1.0);
ld todeg(ld rad) {return rad*180/PI;}
ld torad(ll deg) {return (ld)(deg)*PI/180;}

struct Point {
    ld x,y;
    Point(ld x = 0.0, ld y = 0.0) : x(x), y(y) {}
    friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
inline Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
inline Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
inline Point operator * (const Point &p, ld a) {return Point(p.x * a, p.y * a);}
inline Point operator * (ld a, const Point &p) {return Point(a * p.x, a * p.y);}
inline Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);} //外積
inline Point operator / (const Point &p, ld a) {return Point(p.x / a, p.y / a);}
inline Point conj(const Point &p) {return Point(p.x, -p.y);} //共役
inline Point rot(const Point &p, ld ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
inline Point rot90(const Point &p) {return Point(-p.y, p.x);}
inline Point midl(const Point &p, const Point &q) {return Point((p.x+q.x)/2, (p.y+q.y)/2);}
inline ld cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;} //内積
inline ld dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;} //各点積
inline ld norm(const Point &p) {return dot(p, p);}
inline ld abs(const Point &p) {return sqrt(dot(p, p));}
inline ld ang(const Point &p) {ld res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;} //角度 rad
inline bool eq(const Point &p, const Point &q) {return abs(p - q) < EPS;}
inline bool operator < (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);} // x->y の順
inline bool operator > (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);}

struct Line : vector<Point> {
    Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
        this->emplace_back(a);
        this->emplace_back(b);
    }
    friend ostream& operator << (ostream &s, const Line &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};

int simple_ccw(const Point &a, const Point &b, const Point &c) {
    if (cross(b-a, c-a) > EPS) return 1;
    if (cross(b-a, c-a) < -EPS) return -1;
    return 0;
}
struct Circle : Point {
    ld r;
    Circle(Point p = Point(0.0, 0.0), ld r = 0.0) : Point(p), r(r) {}
    friend ostream& operator << (ostream &s, const Circle &c) {return s << '(' << c.x << ", " << c.y << ", " << c.r << ')';}
};
vector<Point> crosspoint(const Line &l, const Line &m) {
    vector<Point> res;
    ld d = cross(m[1] - m[0], l[1] - l[0]);
    if (abs(d) < EPS) return vector<Point>();
    res.push_back(l[0] + (l[1] - l[0]) * cross(m[1] - m[0], m[1] - l[0]) / d);
    return res;
}
Point centerpoint(const Point &a, const Point &b, const Point &c) {
    Line ab((a+b)/2, (a+b)/2 + rot90(a-b));
    Line bc((b+c)/2, (b+c)/2 + rot90(b-c));
    return crosspoint(ab, bc)[0];
}
Circle makeCircle3(const Point &a, const Point &b, const Point &c){
    Point centerp=centerpoint(a,b,c);
    Circle circle(centerp, abs(centerp-a));
    return circle;
}
Circle makeCircle2(const Point &a, const Point &b){
    Circle circle((a+b)/2,abs(a-b)/2);
    return circle;
}
bool inCircle(const Point &p, const Circle &c){
    return abs(p-c) <= c.r + EPS;
}

Circle minCircle(vector<Point> ps){
    int n=ps.size();
    if(n==1) { Circle res(ps[0],0); return res;}


    mt19937 mt(1111); // seed=1111
    shuffle(ALL(ps), mt);

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

    reps(i,2,n){ // i番目をみる
        if(inCircle(ps[i],c)) continue;
        c=makeCircle2(ps[0],ps[i]); // i番目+[0-i)番目で再構築
        reps(j,1,i){
            if(inCircle(ps[j],c)) continue;
            c=makeCircle2(ps[i],ps[j]); // i番目+j番目+[0-j)番目で再構築
            rep(k,j){
                if(inCircle(ps[k],c)) continue;
                if(simple_ccw(ps[i],ps[j],ps[k]) == 0) continue;
                c=makeCircle3(ps[i],ps[j],ps[k]);
            }
        }
    }
    return c;
}

//--MAIN-----------------------------------
void Main() {
    ll N; cin>>N;
    vector<Point> A(N);
    rep(i,N) cin>>A[i].x>>A[i].y;
    cout<< minCircle(A).r <<"\n";
}

//--START----------------------------------
int main() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    Main();
}
//-----------------------------------------


Measured memory_bytes: 256