#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>

using namespace std;

class Solution {
public:
    double solve(vector<pair<double,double>>& P) {
        double eps = 1e-9;

        auto intersect = [&](pair<double, double>& C1, double R1, pair<double, double>& C2, double R2) {
            vector<pair<double, double>> res;
            auto x1 = C1.first;
            auto y1 = C1.second;
            auto x2 = C2.first;
            auto y2 = C2.second;

            double a = 2 * (x1 - x2);
            double b = 2 * (y1 - y2);
            double c = R2 * R2 - R1 * R1 - (x2 * x2 - x1 * x1) - (y2 * y2 - y1 * y1);

            if (b == 0) {
                double x = c / a;
                double d = R1 * R1 - (x - x1) * (x - x1);
                if (d + eps >= 0) {
                    if (d < 0) {
                        d = 0;
                    }
                    d = sqrt(d);
                    res.emplace_back(x, y1 + d);
                    res.emplace_back(x, y1 - d);
                }
            } else {
                double aa = a / b;
                double bb = y1 - c / b;

                double A = 1 + aa * aa;
                double B = 2 * (aa * bb - x1);
                double C = -(R1 * R1 - x1 * x1 - bb * bb);

                double d = B * B - 4 * A * C;
                if (d + eps >= 0) {
                    if (d < 0) {
                        d = 0;
                    }
                    d = sqrt(d);
                    for (int i = -1; i < 2; i += 2) {
                        double x = (-B + d * i) / (2 * A);
                        double y = (c - a * x) / b;
                        res.emplace_back(x, y);
                    }
                }
            }
            return res;
        };

        auto distance = [&](pair<double,double>& A, pair<double,double>& B) {
            return hypot(A.first - B.first, A.second - B.second);
        };


        auto ok = [&](double R) {
            int n = P.size();

            vector<pair<double, double>> cands;
            for (int i = 0; i < n; ++i) {
                cands.push_back(P[i]);
                for (int j = i + 1; j < n; ++j) {
                    auto S = intersect(P[i], R, P[j], R);
                    for (auto& p : S) {
                        cands.push_back(p);
                    }
                }
            }

            for (auto& p : cands) {
                bool good = true;
                for (int i = 0; i < n; ++i) {
                    if (distance(p, P[i]) < R + eps) {

                    } else {
                        good = false;
                        break;
                    }
                }
                if (good) {
                    return true;
                }
            }
            return false;
        };

        double l = 0, r = 2000;
        int rnd = 200;
        while (rnd-- > 0) {
            auto m = (l + r) / 2;
            if (ok(m)) {
                r = m;
            } else {
                l = m;
            }
        }

        return l;
    }
};

int main(int argc, char** argv) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(12);

    int n;
    cin >> n;
    vector<pair<double,double>> P;
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        P.emplace_back(x, y);
    }
    Solution sol;

    cout << sol.solve(P) << "\n";

    return 0;
}

Measured memory_bytes: 384