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

constexpr double NAN_DOUBLE = numeric_limits<double>::quiet_NaN();
struct Point {
    double x, y;
    bool operator==(const Point& rhs) const {
        return (x == rhs.x && y == rhs.y);
    }
};
Point NAN_POINT = { NAN_DOUBLE, NAN_DOUBLE };

struct Line {
    //a * x + b * y + c = 0
    double a, b, c;
};

struct Circle {
    Point center;
    double r;
};

//a * x^2 + b * x + c = 0を解く
pair<double, double> quadraticEquation(double a, double b, double c) {
    assert(a != 0);
    double in = pow(b, 2) - 4 * a * c;
    if (in < 0) {
        return { NAN_DOUBLE, NAN_DOUBLE };
    } else {
        return { (-b + sqrt(in)) / (2 * a), (-b - sqrt(in)) / (2 * a) };
    }
}

//垂直二等分線
Line verticalBisector(const Point& p1, const Point& p2) {
    Line result;

    //xとyのどっちかは違うとする
    assert(p1.x != p2.x || p1.y != p2.y);

    if (p1.x == p2.x) {
        result.a = 0;
        result.b = 1;
        result.c = -(p1.y + p2.y) / 2;
    } else if (p1.y == p2.y) {
        result.a = 1;
        result.b = 0;
        result.c = -(p1.x + p2.x) / 2;
    } else {
        //p1からp2への傾き
        double grad = (p2.y - p1.y) / (p2.x - p1.x);

        //p1とp2の中点を通る
        double mid_x = (p1.x + p2.x) / 2;
        double mid_y = (p1.y + p2.y) / 2;

        result.a = 1;
        result.b = grad;
        result.c = -(mid_x + mid_y * grad);
    }
    return result;
}

//直線と円の交点
std::pair<Point, Point> crossPoints(const Line& line, const Circle& circle) {
    assert(line.a != 0 || line.b != 0);

    if (line.b == 0) {
        double x = -(line.c / line.a);
        double m = pow(circle.r, 2) - pow(x - circle.center.x, 2);
        if (m < 0) {
            return { NAN_POINT, NAN_POINT };
        }

        return { { x,  circle.center.y + sqrt(m) }, { x, circle.center.y - sqrt(m) } };
    } else {
        //y = -1/b (a * x + c) <=> y = aa * x + bb
        double aa = -(line.a / line.b);
        double bb = -(line.c / line.b);

        //結局a * x^2 + b * x + c = 0の形に直す
        double a = pow(aa, 2) + 1;
        double b = 2 * aa * (bb - circle.center.y) - 2 * circle.center.x;
        double c = pow(circle.center.x, 2) + pow(bb - circle.center.y, 2) - pow(circle.r, 2);

        pair<double, double> solved_x = quadraticEquation(a, b, c);

        if (solved_x.first == NAN_DOUBLE) {
            return { NAN_POINT, NAN_POINT };
        }

        Point p1, p2;
        p1.x = solved_x.first;
        p1.y = aa * p1.x + bb;
        p2.x = solved_x.second;
        p2.y = aa * p2.x + bb;
        return { p1, p2 };
    }
}

bool inCircle(const Point& p, const Circle& c) {
    return pow(p.x - c.center.x, 2) + pow(p.y - c.center.y, 2) <= pow(c.r, 2) + 1e-7;
}

int main() {
    int64_t N;
    cin >> N;

    vector<Point> points(N);
    for (Point& p : points) {
        cin >> p.x >> p.y;
    }

    double ok = 2000, ng = 0;
    for (int64_t _ = 0; _ < 1000; _++) {
        double mid = (ok + ng) / 2;

        bool is_ok = false;
        for (int64_t i = 0; i < N; i++) {
            for (int64_t j = i + 1; j < N; j++) {
                Line vertical_bisector = verticalBisector(points[i], points[j]);

                Circle c{ points[i], mid };

                pair<Point, Point> cross_points = crossPoints(vertical_bisector, c);

                if (cross_points.first == NAN_POINT) {
                    continue;
                }

                for (const Point& center_point : { cross_points.first, cross_points.second }) {
                    bool all_ok = true;
                    Circle circle{ center_point, mid };
                    for (int64_t k = 0; k < N; k++) {
                        if (!inCircle(points[k], circle)) {
                            all_ok = false;
                            break;
                        }
                    }
                    if (all_ok) {
                        is_ok = true;
                    }
                }
            }
        }

        (is_ok ? ok = mid : ng = mid);
    }

    cout << setprecision(10) << ok << endl;
}

Measured memory_bytes: 256