#pragma region Macros
#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;

template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }

constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr long long MOD = 1e9 + 7;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
#pragma endregion

class Point {
    public:
        double x, y;
        Point(double xx = 0.0, double yy = 0.0) : x(xx), y(yy) {}
        Point operator=(const Point &p) { x = p.x; y = p.y; return *this; }
};
inline Point operator+(const Point &p) { return Point(p.x, p.y); }
inline Point operator-(const Point &p) { return Point(-p.x, -p.y); }
inline Point operator+(const Point &p, const Point &q) { return Point(p.x + q.x, p.y + q.y); }
inline Point operator-(const Point &p, const Point &q) { return Point(p.x - q.x, p.y - q.y); }
inline Point operator+=(Point &p, const Point &q) { p.x += q.x; p.y += q.y; return p; }
inline Point operator-=(Point &p, const Point &q) { p.x -= q.x; p.y -= q.y; return p; }
inline Point operator*(const Point &p, double v) { return Point(p.x * v, p.y * v); }
inline Point operator*(double v, const Point &p) { return Point(p.x * v, p.y * v); }
inline Point operator/(const Point &p, double v) { return Point(p.x / v, p.y / v); }
inline Point rot(const Point &p, double angle) { return Point(std::cos(angle) * p.x - std::sin(angle) * p.y, std::sin(angle) * p.x + std::cos(angle) * p.y); }
inline Point rot90(const Point &p) { return Point(-p.y, p.x); }
inline double dot(const Point &p, const Point &q) { return p.x * q.x + p.y * q.y; }
inline double abs(const Point &p) { return sqrt(dot(p, p)); }
inline double dis(const Point &p, const Point &q) { return abs(p - q); }
inline bool eq(const Point &p, const Point &q) { return dis(p, q) < EPS; }
inline std::istream& operator>>(std::istream &s, Point &p) { return s >> p.x >> p.y; }
inline std::ostream& operator<<(std::ostream &s, const Point &p) { return s << "(" << p.x << ", " << p.y << ")"; }

// circumcenter 外心
Point circumcenter(const Point &a, const Point &b, const Point &c) {
    double A = std::acos(dot(b-a, c-a) / dis(a, b) / dis(a, c)),
           B = std::acos(dot(c-b, a-b) / dis(b, c) / dis(b, a)),
           C = std::acos(dot(a-c, b-c) / dis(c, a) / dis(c, b));
    double sin2A = std::sin(A * 2.0), sin2B = std::sin(B * 2.0), sin2C = std::sin(C * 2.0);
    return Point((a.x * sin2A + b.x * sin2B + c.x * sin2C) / (sin2A + sin2B + sin2C),
                 (a.y * sin2A + b.y * sin2B + c.y * sin2C) / (sin2A + sin2B + sin2C));
}

void solve() {
    int n;
    cin >> n;
    vector<Point> p(n);
    for (int i=0; i<n; i++) {
        cin >> p.at(i);
    }
    vector<Point> alt;
    for (int i=0; i<n; i++) {
        for (int j=i+1; j<n; j++) {
            alt.push_back((p.at(i) + p.at(j)) / 2.0);
            for (int k=j+1; k<n; k++) {
                if (abs((p.at(i).x - p.at(j).x) * (p.at(i).y - p.at(k).y) - (p.at(i).y - p.at(j).y) * (p.at(i).x - p.at(k).x)) > EPS) {
                    alt.push_back(circumcenter(p.at(i), p.at(j), p.at(k)));
                }
            }
        }
    }
    double res = LINF;
    for (auto al : alt) {
        double tmp = 0;
        for (auto pp : p) {
            chmax(tmp, dis(al, pp));
        }
        chmin(res, tmp);
    }
    cout << res << "\n";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(20);

    solve();

    return 0;
}


Measured memory_bytes: 888