#include <bits/stdc++.h>

using namespace std;

template<typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T> p) {
    out << "(" << p.first << "," << p.second << ")";
    return out;
}

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
    for (auto a: v)
        out << a << " ";
    return out;
}

template<typename T>
ostream& operator<<(ostream& out, const set<T>& S) {
    for (auto a: S)
        cout << a << " ";
    return out;
}

template<typename T>
ostream& operator<<(ostream& out, const multiset<T>& S) {
    for (auto a: S)
        cout << a << " ";
    return out;
}

template<typename S, typename T>
ostream& operator<<(ostream& out, const map<S, T>& M) {
    for (auto m: M)
        cout << "(" << m.first << "->" << m.second << ") ";
    return out;
}

template<typename S, typename T>
pair<S, T> operator+(pair<S, T> a, pair<S, T> b) {
    return make_pair(a.first + b.first, a.second + b.second);
}

template<typename S, typename T>
pair<S, T> operator-(pair<S, T> a, pair<S, T> b) {
    return make_pair(a.first - b.first, a.second - b.second);
}

template<typename T>
struct ComplexGeometry {
    using point = complex<T>;
    vector<point> A;
    point smallest_enclosing_circle_center;
    T smallest_enclosing_circle_radius;
    T inf = numeric_limits<T>::max();
    void init() {
        A.clear();
    }
    void add_point(complex<T> a) {
        A.push_back(a);
    }
    void add_point(T x, T y) {
        A.emplace_back(x, y);
    }
    void remove_duplicate() {
        int n = A.size();
        auto cmp = [&](point a, point b) {
            if (a.real() != b.real())
                return a.real() < b.real();
            return a.imag() < b.imag();
        };
        set<point, decltype(cmp)> S(cmp);
        for (int i = 0, j = 0; i < n; i++) {
            if (S.insert(A[i]).second) {
                A[j++] = A[i];
            }
            if (!S.count(A[i])) {
                A[j] = A[i];
                S.insert(A[i]);
            }
        }
        A.resize(S.size());
    }
    T static cross(point a, point b) {
        return (conj(a) * b).imag();
    }
    T static cross(point a, point b, point c) {
        return cross(b - a, c - a);
    }
    T static dot(point a, point b) {
        return (conj(a) * b).real();
    }
    point query_line_intersection(point a, point b, point p, point q) {
        T c1 = cross(p - a, b - a), c2 = cross(q - a, b - a);
        return (c1 * q - c2 * p) / (c1 - c2); // undefined if parallel
    }
    T query_line_point_distance(point s, point t, point a) {
        if (s == t)
            return abs(a - s);
        return abs(cross(s, t, a)) / abs(s - t);
    }
    point query_triangle_circumcenter(point a, point b, point c) {
        point d = (a + b) * polar<T>(0.5, 0.0);
        point e = d + (b - a) * polar<T>(1.0, acos(0.0));
        point f = (b + c) * polar<T>(0.5, 0.0);
        point g = f + (c - b) * polar<T>(1.0, acos(0.0));
        return query_line_intersection(d, e, f, g);
    }
    point query_triangle_circumcenter(const vector<point>& A) {
        if (A.size() != 3)
            return point(0.0, 0.0);
        return query_triangle_circumcenter(A[0], A[1], A[2]);
    }
    point query_triangle_incenter(vector<point>& A) {
        if (A.size() != 3)
            return point(0.0, 0.0);
        return query_triangle_incenter(A[0], A[1], A[2]);
    }
    point query_triangle_incenter(point a, point b, point c) {
        T A = abs(b - c);
        T B = abs(c - a);
        T C = abs(a - b);
        point p = a * polar<T>(A, 0.0) + b * polar<T>(B, 0.0) + c * polar<T>(C, 0.0);
        p = p / polar<T>(A + B + C, 0.0);
        return p;
    }
    point query_smallest_enclosing_circle_center() {
        return smallest_enclosing_circle_center;
    }
    T query_smallest_enclosing_circle_radius() {
        return smallest_enclosing_circle_radius;
    }
    void source_smallest_enclosing_circle() {
        point &circle_center =  smallest_enclosing_circle_center;
        T &circle_radius = smallest_enclosing_circle_radius;
        circle_radius = inf;
        int n = A.size();
        if (n == 0)
            return;
        if (n == 1) {
            circle_center = A[0];
            circle_radius = 0;
            return;
        }
        T min_val = inf;
        T eps = 1e-6;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                point center = (A[i] + A[j]) * polar<T>(0.5, 0.0);
                double radius = 0.5 * abs(A[i] - A[j]);
                int cnt = 0;
                for (int k = 0; k < n; k++) {
                    if (abs(A[k] - center) <= radius + eps) {
                        cnt++;
                    }
                }
                if (cnt == n) {
                    if (circle_radius > radius) {
                        circle_radius = radius;
                        circle_center = center;
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    vector<T> B(3);
                    B[0] = abs(A[i] - A[j]);
                    B[1] = abs(A[j] - A[k]);
                    B[2] = abs(A[k] - A[i]);
                    sort(B.begin(), B.end());
                    if (pow(B[2], 2) <= pow(B[0], 2) + pow(B[1], 2) + eps) {
                        point center = query_triangle_circumcenter(A[i], A[j], A[k]);
                        T radius = abs(center - A[i]);
                        int cnt = 0;
                        for (int l = 0; l < n; l++) {
                            if (abs(A[l] - center) <= radius + 1e-6) {
                                cnt++;
                            }
                        }
                        if (cnt == n) {
                            if (circle_radius > radius) {
                                circle_radius = radius;
                                circle_center = center;
                            }
                        }
                    }
                }
            }
        }
    }
    void dump_point() {
        int n = A.size();
        cout << __func__ << endl;
        cout << "n: " << n << endl;
        cout << "A: " << A << endl;
    }
    void dump() {
        cout << __func__ << endl;
        cout << "query_smallest_enclosing_circle_center: " << query_smallest_enclosing_circle_center() << endl;
        cout << "query_smallest_enclosing_circle_radius: " << query_smallest_enclosing_circle_radius() << endl;
    }
};

ComplexGeometry<double> geometry;
using point = complex<double>;

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n;
    geometry.init();
    cin >> n;
    for (int i = 0; i < n; i++) {
        double a, b;
        cin >> a >> b;
        geometry.add_point(point(a, b));
    }
    // geometry.dump_point();
    geometry.source_smallest_enclosing_circle();
    cout << fixed << setprecision(6) << geometry.query_smallest_enclosing_circle_radius() << endl;
    return 0;
}


Measured memory_bytes: 256