#include<bits/stdc++.h>

using namespace std;

#define int long long
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))

typedef pair<int,int> PI;
typedef pair<int,pair<int,int>> PII;
static const int INF=1010000000000000017LL;
static const double eps=1e-12;
static const double pi=3.14159265358979323846;
static const int dx[4]={1,-1,0,0};
static const int dy[4]={0,0,1,-1};
static const int ddx[8]={1,-1,0,0,1,1,-1,-1};
static const int ddy[8]={0,0,1,-1,1,-1,1,-1};

template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;}

template<typename T>
class Vector2 {
public :
    T x, y;
    Vector2() {}
    Vector2(T x, T y) : x(x), y(y) {}
    void operator = (const Vector2 &other) {
        if(this != &other){
            x = other.x;
            y = other.y;
        }
    }
    bool operator == (const Vector2 &other) {
        return (x == other.x && y == other.y);
    }
    T dot(Vector2 other) {
        return x * other.x + y * other.y;
    }
    T det(Vector2 other) {
        return x * other.y - y * other.x;
    }
    T squared_norm() {
        return x * x + y * y;
    }
    double norm() {
        return sqrt(squared_norm());
    }
};

template<typename T>
inline Vector2<T> operator + (const Vector2<T> &a, const Vector2<T> &b) {
    return Vector2<T>(a.x + b.x, a.y + b.y);
}
template<typename T>
inline Vector2<T> operator - (const Vector2<T> &a, const Vector2<T> &b) {
    return Vector2<T>(a.x - b.x, a.y - b.y);
}
template<typename T>
inline Vector2<T> operator * (const Vector2<T> &a, T b) {
    return Vector2<T>(a.x * b, a.y * b);
}
template<typename T>
inline Vector2<T> operator * (T b, const Vector2<T> &a) {
    return Vector2<T>(a.x * b, a.y * b);
}
template<typename T>
inline Vector2<T> operator / (const Vector2<T> &a, T b) {
    return Vector2<T>(a.x / b, a.y / b);
}
template<typename T>
inline Vector2<T> operator / (T b, const Vector2<T> &a) {
    return Vector2<T>(a.x / b, a.y / b);
}
template<typename T>
inline Vector2<T> rot90(const Vector2<T> &p) {
    return Vector2<T>(-p.y, p.x);
} 

template<typename T>
class Line {
public :
    Vector2<T> start, end;
    Line() {}
    Line(Vector2<T> start, Vector2<T> end) : start(start), end(end) { auto a  = this->end - this->start;}
};

template<typename T>
int ccw(Vector2<T> a, Vector2<T> b, Vector2<T> c) {
    b = b - a;
    c = c - a;
    if (b.det(c) > 0) return 1; // counter clockwise
    if (b.det(c) < 0) return -1;// clockwise
    if (b.dot(c) < 0) return -2;// c--a--b on line
    if (b.norm() < c.norm()) return 2;// // a--b--c on line
    return 0;
}

Vector2<double> crossPoint(const Line<double> &l, const Line<double> &m) {
    auto d = (m.end - m.start).det(l.end - l.start);
    if(abs(d) < eps) return Vector2<double>(0.0, 0.0);
    auto res = (l.start + (l.end - l.start) * ((m.end - m.start).det(m.end - l.start) / d));
    return res;
}

Vector2<double> circumcenter(Vector2<double> &a, Vector2<double> &b, Vector2<double> &c) {
    Line<double> ab((a + b) / 2.0, (a + b) / 2.0 + rot90(a - b));
    Line<double> bc((b + c) / 2.0, (b + c) / 2.0 + rot90(b - c));
    return crossPoint(ab, bc);
} 

int N;
vector<Vector2<double>> v;

signed main(){
    cin>>N;
    for(int i=0;i<N;++i){
        double x,y;
        cin>>x>>y;
        v.push_back(Vector2<double>(x,y));
    }
    vector<Vector2<double>> alt;
    for(int i=0;i<N;++i){
        for(int j=i+1;j<N;++j){
            alt.push_back((v[i]+v[j])/2.0);
            for(int k=j+1;k<N;++k){
                if(abs(ccw(v[i],v[j],v[k]))==2)continue;
                auto r=circumcenter(v[i],v[j],v[k]);
                alt.push_back(r);
            }
        }
    }
    double ans=INF;
    for(auto r:alt){
        double tmp=0.0;
        for(auto p:v) chmax(tmp,(p-r).norm());
        chmin(ans,tmp);
    }
    printf("%.20f\n",ans);
}

Measured memory_bytes: 4000