#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <tuple>
#include <deque>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cassert>
#include <chrono>
#include <random>
#include <limits>
#include <iterator>
#include <functional>
#include <sstream>
#include <complex>
using namespace std;

typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932;   // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;

#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod

using ld = long double;
using Point = complex<ld>;
using Set = vector<Point>;
const ld pi = acos(-1);
const ld eps = 1e-10;
const ld inf = 1e12;

// 外積
ld cross(const Point& a, const Point& b){
    return a.real() * b.imag() - a.imag() * b.real();
}

// 内積
ld dot(const Point& a, const Point& b){
    return a.real() * b.real() + a.imag() * b.imag();
}

enum CCW_RESULT{
    CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0
};
// a, b に対して、c がどの位置にあるか
int ccw(Point a, Point b, Point c){
    b -= a, c -= a;
    if(cross(b, c) > eps)   return CCW;     // 上側
    if(cross(b, c) < -eps)  return CW;      // 下側
    
    // cross(b, c) == 0
    if(dot(b, c) < 0)   return BEHIND;      // 同一直線上の左側
    if(norm(b) < norm(c))   return FRONT;   // 同一直線上の右側
    return ON;      // 線分 ab 上にある
}

bool operator<(const Point& a, const Point &b){
    return abs(real(a) - real(b)) > eps ? real(a) < real(b) : imag(a) < imag(b);
}

// 直線
struct Line : public vector<Point>{
    Line(const Point& a = Point(), const Point& b = Point()) : vector<Point>(2){
        begin()[0] = a;
        begin()[1] = b;
    }

    // Ax + By + C = 0
    Line(ld A, ld B, ld C){
        if(abs(A) < eps && abs(B) < eps){
            abort();
        }
        else if(abs(A) < eps){
            *this = Line(Point(0, -C / B), Point(1, -C / B));
        }
        else if(abs(B) < eps){
            *this = Line(Point(-C / A, 0), Point(-C / A, 1));
        }
        else{
            *this = Line(Point(0, -C / B), Point(-C / A, 0));
        }
    }
};

// 円
struct Circle{
    Point center;   // 中心座標
    ld radius;      // 半径
    Circle(const Point& p = 0, ld r = 0) : center(p), radius(r) {}
};

// 点集合 [left, right) に対する、最小包含円の中心座標と半径を返す。
template<class iter>
Circle min_ball(iter left, iter right, int seed = 1333){
    const int n = right - left;
    
    assert(n >= 1);
    if(n == 1)  return {*left, ld(0)};

    mt19937 mt(seed);
    shuffle(left, right, mt);
    
    iter ps = left;

    // 同一直線上にない 3 頂点の外心と、外接円の半径を返す
    auto make_circle_3 = [](const Point& a, const Point& b, const Point& c) -> Circle{
        ld A = norm(b - c), B = norm(c - a), C = norm(a - b), S = cross(b - a, c - a);
        Point center = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        ld radius = norm(center - a);
        return Circle(center, radius);
    };
    
    auto make_circle_2 = [](const Point& a, const Point& b) -> Circle{
        Point center = (a + b) / (ld)2;
        ld radius = norm(a - center);
        return Circle(center, radius);
    };

    auto in_circle = [](const Point& a, const Circle& c) -> bool{
        return norm(a - c.center) <= c.radius + eps;
    };

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

    // MiniDisc
    for(int i = 2; i < n; ++i){
        if(!in_circle(ps[i], c)){
            // MiniDiscWithPoint
            c = make_circle_2(ps[0], ps[i]);
            for(int j = 1; j < i; ++j){
                // MiniDiscWith2Points
                if(!in_circle(ps[j], c)){
                    c = make_circle_2(ps[i], ps[j]);
                    for(int k = 0; k < j; ++k){
                        if(!in_circle(ps[k], c)){
                            c = make_circle_3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    
    return c;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<Point> ps(n);
    for(int i = 0; i < n; ++i){
        ld x, y;
        cin >> x >> y;
        ps[i] = Point(x, y);
    }

    cout << fixed << setprecision(18);
    Circle c = min_ball(ps.begin(), ps.end());
    cout << sqrt(c.radius) << endl;
}

Measured memory_bytes: 384