#include <bits/stdc++.h>
#define int long long
#define double long double
#define rep(i, a, n) for(int i = (int)(a);(i) < (int)(n);++(i))
#define repe(i, a, n) for(int i = (int)(a);(i) <= (int)(n);++(i))
#define repif(i, a, x) for(int i = (int)(a);(x);++(i))
#define repr(i, a, n) for(int i = ((int)(a)-1);(i) >= (int)(n);--(i))
#define reper(i, a, n) for(int i = (int)(a);(i) >= (int)(n);--(i))
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define CEIL(x) ((int)ceil(((double)x)))
#define POW(x, y) ((int)pow(x, y))
#define UNIQUE(x) (x).erase(unique(ALL((x))), end(x))
#define gcd(x, y) __gcd(x, y)
#define lcm(x, y) ((x)/gcd(x,y)*(y))
#define isin(x, l, r) ((l) <= (x) and (x) < (r))
#define fcout(n) cout << fixed << setprecision(n)
#define rcout(n) cout << right << setw(n)
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define PI (acosl(-1))
#define EPS (1e-10)
#define INF LLONG_MAX
#define INF32 INT32_MAX
#define MOD 1000000007LL
using namespace std;
using VI = vector<int>;
using PII = pair<int, int>;
using TIII = tuple<int, int, int>;
using VPII = vector<PII>;
using VTIII = vector<TIII>;
using Complex = complex<double>;
template<typename T, template<typename> typename C = less> using PQ = priority_queue<T, vector<T>, C<T>>;
template<typename T> bool chmax(T& a, const T& b, bool t = false){ if(a<b or (t and a == b)){ a=b; return true; } return false; }
template<typename T> bool chmin(T& a, const T& b, bool t = false){ if(a>b or (t and a == b)){ a=b; return true; } return false; }


//COUNTER CLOCKWISE
constexpr int CCW_COUNTER_CLOCKWISE = 1;
constexpr int CCW_CLOCKWISE = -1;
constexpr int CCW_ONLINE_BACK = 2;
constexpr int CCW_ONLINE_FRONT = -2;
constexpr int CCW_ON_SEGMENT = 0;


//Point
struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y){}
    friend ostream& operator<<(ostream& os, const Point& p){ return os << '(' << 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, double a){ return Point(p.x*a, p.y*a); }
inline Point operator*(double a, const Point& p){ return Point(a*p.x, a*p.y); }
inline Point operator / (const Point& p, double 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, double 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 double cross(const Point& p, const Point& q){ return p.x*q.y-p.y*q.x; }
inline double dot(const Point& p, const Point& q){ return p.x*q.x+p.y*q.y; }
inline double norm(const Point& p){ return p.x*p.x+p.y*p.y; }
inline double abs(const Point& p){ return sqrtl(norm(p)); }
inline double amp(const Point& p){ double res = atan2(p.y, p.x); if(res < 0) res+=PI*2; return res; }
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); }
inline bool operator>(const Point &p, const Point &q){ return (abs(p.x-q.x) > EPS ? p.x > q.x : p.y > q.y); }


/* Line */
struct Line{
    Point p1, p2;
    Line(Point p1 = Point(), Point p2 = Point()) : p1(p1), p2(p2){}
    const Point& operator[](bool i) const { return i ? p2 : p1; }
    Point& operator[](bool i){ return i ? p2 : p1; }
    friend ostream& operator<<(ostream& s, const Line& l){ return s << '{' << l[0] << ", " << l[1] << '}'; }
};


int ccw(const Point& a, const Point& b, const Point& c){
    if(cross(b-a, c-a) > EPS) return CCW_COUNTER_CLOCKWISE;
    if(cross(b-a, c-a) < -EPS) return CCW_CLOCKWISE;
    if(dot(b-a, c-a) < -EPS) return CCW_ONLINE_BACK;
    if(norm(b-a) < norm(c-a)) return CCW_ONLINE_FRONT;
    return CCW_ON_SEGMENT;
}


vector<Point> crosspoint(const Line& l, const Line& m) {
    vector<Point> res;
    double 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 circumcenter(Point a, Point b, 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];
}


int N;
Point p[60];


signed main(){
    cin >> N;
    rep(i, 0, N) cin >> p[i].x >> p[i].y;

    double ans = INF;
    rep(i, 0, N) rep(j, i+1, N) rep(k, j+1, N){
        if(ccw(p[i], p[j], p[k]) != CCW_COUNTER_CLOCKWISE and ccw(p[i], p[j], p[k]) != CCW_CLOCKWISE) continue;
        auto c = circumcenter(p[i], p[j], p[k]);
        double r = abs(c-p[i]);
        bool f = true;
        rep(l, 0, N) if(l != i and l != j and k != l and abs(c-p[l]) > r) f = false;
        if(f) chmin(ans, r);
    }
    rep(i, 0, N) rep(j, i+1, N){
        auto c = (p[i]+p[j])/2;
        double r = abs(c-p[i]);
        bool f = true;
        rep(k, 0, N) if(k != i and k != j and abs(c-p[k]) > r) f = false;
        if(f) chmin(ans, r);
    }

    fcout(20) << ans << endl;

    return 0;
}

Measured memory_bytes: 256