#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using uint = unsigned int;
using matrix = vector<vector<uint>>;
template <typename T>
using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;

const ld EPS = 1e-10;
struct Pt {
    ld x, y;
    Pt(ld x = 0, ld y = 0) : x(x), y(y) {}
};
istream &operator>>(istream &stream, Pt &p) {
    stream >> p.x >> p.y;
    return stream;
}
inline Pt operator+(const Pt &p, const Pt &q) {
    return Pt(p.x + q.x, p.y + q.y);
}
inline Pt operator-(const Pt &p, const Pt &q) {
    return Pt(p.x - q.x, p.y - q.y);
}
inline Pt operator*(const ld &a, const Pt &p) {
    return Pt(p.x * a, p.y * a);
}
inline ld dot(const Pt &p, const Pt &q) {
    return p.x * q.x + p.y * q.y;
}
inline ld cross(const Pt &p, const Pt &q) {
    return p.x * q.y - p.y * q.x;
}
inline ld norm(const Pt &p) {
    return dot(p, p);
}
inline ld dist(const Pt &p, const Pt &q) {
    return sqrtl(norm(p - q));
}

struct Line {
    Pt s, t;
    Line(Pt s = {0, 0}, Pt t = {0, 0}) : s(s), t(t) {}
};
istream &operator>>(istream &stream, Line &l) {
    stream >> l.s >> l.t;
    return stream;
}

inline int ccw(const Pt &p1, const Pt &p2, const Pt &q) {
    // qはp1-p2の左側
    if (cross(p2 - p1, q - p1) > EPS)
        return 1;
    // qはp1-p2の右側
    if (cross(p2 - p1, q - p1) < -EPS)
        return -1;
    // q-p1-p2
    if (dot(p2 - p1, q - p1) < -EPS)
        return 2;
    // p1-p2-q
    if (norm(p2 - p1) < norm(q - p1) - EPS)
        return -2;
    // p1-q-p2
    return 0;
}

inline int ccw(const Line &l, const Pt &q) {
    return ccw(l.s, l.t, q);
}

inline bool intersect(const Line &l, const Line &m) {
    return (ccw(l, m.s) * ccw(l, m.t) <= 0 && ccw(m, l.s) * ccw(m, l.t) <= 0);
}

inline Line bisec(const Line &l) {
    Pt vvec = {l.t - l.s};
    swap(vvec.x, vvec.y);
    vvec.x = -vvec.x;
    Pt spt = 0.5 * (l.s + l.t);
    return Line(spt, spt + vvec);
}

inline Pt crosspoint(const Line &l, const Line &m) {
    ld k = cross(m.s - l.s, m.s - m.t) / cross(l.t - l.s, m.s - m.t);
    return l.s + k * (l.t - l.s);
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int N;
    cin >> N;
    vector<Pt> p(N);
    for (int i = 0; i < N; ++i)
        cin >> p[i];

    auto isok = [&](Pt c, ld r) -> bool {
        for (int i = 0; i < N; ++i)
            if (dist(c, p[i]) > r - EPS)
                return false;
        return true;
    };

    auto search = [&](Pt c) -> ld {
        ld ok = 800, ng = 0;
        for (int i = 0; i < 40; ++i) {
            ld mid = (ok + ng) / 2;
            (isok(c, mid) ? ok : ng) = mid;
        }
        return ok;
    };

    ld ans = 1e18;
    for (int i = 0; i < N; ++i) {
        for (int j = i + 1; j < N; ++j) {
            {
                Pt c = 0.5 * (p[i] + p[j]);
                ans = min(search(c), ans);
            }
            for (int k = j + 1; k < N; ++k) {
                if (!(ccw(p[i], p[j], p[k]) & 1))
                    continue;
                Pt c = crosspoint(bisec(Line(p[i], p[j])), bisec(Line(p[j], p[k])));
                ans = min(search(c), ans);
            }
        }
    }

    printf("%.10Lf\n", ans);
    return 0;
}


Measured memory_bytes: 384