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

struct P { long double x, y; };
struct C { P c; long double r; };

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

Circle circle2(const P& a, const P& b) {
    P m = {(a.x + b.x) / 2.0L, (a.y + b.y) / 2.0L};
    return {m, sqrtl(dist2(a, b)) / 2.0L};
}

Circle circle3(const P& a, const P& b, const P& c) {
    long double A = b.x - a.x, B = b.y - a.y;
    long double Cx = c.x - a.x, Cy = c.y - a.y;
    long double d = 2 * (A * Cy - B * Cx);
    if (fabsl(d) < 1e-18L) { // Thẳng hàng
        Circle c1 = circle2(a, b);
        Circle c2 = circle2(a, c);
        Circle c3 = circle2(b, c);
        Circle res = c1;
        if (c2.r > res.r) res = c2;
        if (c3.r > res.r) res = c3;
        return res;
    }
    long double a2 = A * A + B * B, c2 = Cx * Cx + Cy * Cy;
    long double ux = a.x + (Cy * a2 - B * c2) / d;
    long double uy = a.y + (-Cx * a2 + A * c2) / d;
    P o = {ux, uy};
    return {o, sqrtl(dist2(o, a))};
}

bool inside(const Circle& cir, const P& p) {
    return dist2(cir.c, p) <= (cir.r + 1e-12L) * (cir.r + 1e-12L);
}

Circle solve(vector<P> pts) {
    random_shuffle(pts.begin(), pts.end());
    Circle C = {{0, 0}, 0};
    for (int i = 0; i < pts.size(); i++) {
        if (inside(C, pts[i])) continue;
        C = {pts[i], 0};
        for (int j = 0; j < i; j++) {
            if (inside(C, pts[j])) continue;
            C = circle2(pts[i], pts[j]);
            for (int k = 0; k < j; k++) {
                if (inside(C, pts[k])) continue;
                C = circle3(pts[i], pts[j], pts[k]);
            }
        }
    }
    return C;
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    int n; cin >> n;
    vector<P> pts(n);
    for (auto& p : pts) cin >> p.x >> p.y;
    Circle ans = solve(pts);
    cout << fixed << setprecision(3) << ans.r << endl;
    return 0;
}

// Code minh họa cho cách tiếp cận Prune-and-Search (Megiddo)
// Thường được chia nhỏ thành các bài toán con con
// Dưới đây là code tổng quan của một giải pháp Prune-and-Search
#include <bits/stdc++.h>
using namespace std;

// Cấu trúc Point và Circle tương tự như trên
// ... (giữ nguyên các hàm phụ)

Circle solve_deterministic(vector<Point>& S) {
    // Chia S thành các nhóm 5 phần tử
    // Tìm trung vị của các trung vị (Median of Medians)
    // Dùng làm trục để loại bỏ (prune) các điểm không thể là điểm biên
    // Lặp lại cho đến khi |S| <= 3
    // Trả về đường tròn nhỏ nhất bao bọc S
    // Chi tiết implementation khá phức tạp, thường chỉ dùng trong lý thuyết
    // Code dưới đây là pseudocode logic:
    if (S.size() <= 3) return trivial(S);

    // Bước 1: Chia đều S thành các nhóm 5
    // Bước 2: Tìm median của các median, gọi là M
    // Bước 3: Dùng M để loại bỏ các điểm không thể là điểm biên (dựa trên các ràng buộc hình học)
    // Bước 4: Recurse trên tập hợp còn lại
    return Circle(); 
}