#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
const int INF = int (1e9) + int (1e5);
const ll INFL = ll(2e18) + ll(1e10);
const ui MOD = 1E9 + 7;
const double EPS = 1e-9;
#define FOR(i,n) for (int i=0;i<(n);++i)
#define ROF(i,x) for(int i = (x) ; i >= 0 ; --i)
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define ODD(x) (((x)&1)==0?(0):(1))
#define sign(x) ((x > 0) - (x < 0))
#define dbg(x) cerr << #x"= " << x << endl
std::mt19937_64  generator(std::chrono::system_clock::now().time_since_epoch().count());


void READ(bool _local){
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _DEBUG
    if (_local)
        freopen ("in.txt", "r", stdin);
#endif
}

// encuentra el círculo más chico que contiene a un conjunto de puntos

// funciones de comparación contemplando error de redondeo
inline bool lt(const double &a,const double &b){return a+EPS<b;}
inline bool le(const double &a,const double &b){return a<b+EPS;}
inline bool gt(const double &a,const double &b){return a>b+EPS;}
inline bool ge(const double &a,const double &b){return a+EPS>b;}
inline bool eq(const double &a,const double &b){return fabs(a-b)<EPS;}

struct point{
    double x,y;
    point():x(0),y(0){}
    point(double _x,double _y):x(_x),y(_y){}

    point operator+(const point &o){return point(x+o.x,y+o.y);}
    point operator-(const point &o){return point(x-o.x,y-o.y);}
    point operator*(const double &d){return point(x*d,y*d);}
    point operator/(const double &d){return point(x/d,y/d);}


    double dot(const point& p) const { return x*p.x + y*p.y; }
    double crux(const point& p) const { return x*p.y - y*p.x; }

    bool operator==(const point &o){return eq(x,o.x) && eq(y,o.y);}
};

double dist2(const point &a,const point &b){
    double x=a.x-b.x, y=a.y-b.y;
    return x*x+y*y;
}

double dist(const point &a,const point &b){
    return sqrt(dist2(a,b));
}
struct circle {
    point centro;
    double radio;
    circle(point c=point(), double r=0) : centro(c), radio(r) {}

    bool is_inside(const point &p) {
        return le(dist2(p, centro) ,  radio * radio);
    }
};


circle circumCircle(point &a, point &b, point &c) {
    if (a == b || a == c)
        return circle((b + c) * 0.5, dist(b, c) * 0.5);
    if (b == c)
        return circle((a + c) * 0.5, dist(a, c) * 0.5);
    point bb = b - a, cc = c - a;
    double db = (bb.x*bb.x+bb.y*bb.y), dc = cc.x*cc.x+cc.y*cc.y, d= bb.crux(cc)*2;
    circle cir;
    cir.centro = a-point(bb.y*dc-cc.y*db, cc.x*db-bb.x*dc) / d;
    cir.radio = dist(cir.centro, a);
    return cir;
}

circle findCircleRec(vector<point>& vp, int enborde, int num) {
    if (enborde == 3)
        return circumCircle(vp[0], vp[1], vp[2]);
    circle cir = circumCircle(vp[0], vp[0], vp[1]);
    for (int i = enborde; i < num; ++i) {
        if (cir.is_inside(vp[i])) continue;
        swap(vp[i], vp[enborde]);
        cir = findCircleRec(vp, enborde+1, i+1);
    }
    return cir;
}

circle findCircle(vector<point>& vp) {
    shuffle(vp.begin(), vp.end(), generator);
    return findCircleRec(vp, 0, vp.size());
}



int main(){
    READ(0);
    int n;cin>>n;
    vector<point> v(n);
    for(int i=0;i<n;++i){
        cin>>v[i].x>>v[i].y;
    }
    if (n>2) {
        circle c = findCircle(v);
        cout << setprecision(9) << fixed << c.radio;
    }else{
        cout << setprecision(9) << fixed<< dist(v[0],v[1])/2;
    }

    return 0;
}


Measured memory_bytes: 256