#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

constexpr int I_INF = (1 << 30);
constexpr ll L_INF = (1ll << 62);

//==================================

using Pdd = pair<double, double>;

double distsq(const Pdd& a, const Pdd& b) {
    double t1, t2;
    t1 = a.first - b.first;
    t2 = a.second - b.second;
    return t1 * t1 + t2 * t2;
}

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

    int N;
    cin >> N;

    vector<Pdd> cds(N);
    for (int i = 0; i < N; ++i) {
        cin >> cds[i].first >> cds[i].second;
    }

    if (N == 2) {
        cout << sqrt(distsq(cds[0], cds[1])) / 2.0 << endl;
        return 0;
    }

    double ans = 1e+20;
    for (int i = 0; i < N - 2; ++i) {
        for (int j = i + 1; j < N - 1; ++j) {
            double xa, ya, xb, yb;
            tie(xa, ya) = cds[i];
            tie(xb, yb) = cds[j];

            double r_sq = distsq(cds[i], cds[j]) / 4.0;
            Pdd cen;
            cen.first = (xa + xb) / 2.0;
            cen.second = (ya + yb) / 2.0;

            bool ok = true;
            for (int k = 0; k < N; ++k) {
                double d = distsq(cen, cds[k]);
                if (d > r_sq + 1e-9) {
                    ok = false;
                    break;
                }
            }

            if (ok) {
                ans = min(ans, r_sq);
            }
        }
    }

    for (int i = 0; i < N - 2; ++i) {
        for (int j = i + 1; j < N - 1; ++j) {
            for (int k = j + 1; k < N; ++k) {
                double al, bl, cl, am, bm, cm;
                double xa, ya, xb, yb, xc, yc;
                tie(xa, ya) = cds[i];
                tie(xb, yb) = cds[j];
                tie(xc, yc) = cds[k];
                al = xa - xb;
                bl = ya - yb;
                cl = (xa * xa - xb * xb + ya * ya - yb * yb) / 2.0;
                am = xb - xc;
                bm = yb - yc;
                cm = (xb * xb - xc * xc + yb * yb - yc * yc) / 2.0;

                double det = al * bm - am * bl;
                Pdd cen;
                double r_sq;
                if (abs(det) < 1e-9) {
                    int idx1, idx2;
                    int tmp;
                    r_sq = distsq(cds[i], cds[j]);
                    idx1 = i, idx2 = j;
                    tmp = distsq(cds[j], cds[k]);
                    if (r_sq < tmp) {
                        r_sq = tmp;
                        idx1 = j, idx2 = k;
                    }
                    tmp = distsq(cds[k], cds[i]);
                    if (r_sq < distsq(cds[k], cds[i])) {
                        r_sq = tmp;
                        idx1 = k, idx2 = i;
                    }
                    cen.first = (cds[idx1].first + cds[idx2].first) / 2.0;
                    cen.second = (cds[idx1].second + cds[idx2].second) / 2.0;
                }
                else {
                    cen.first = (bm * cl - bl * cm) / det;
                    cen.second = (-am * cl + al * cm) / det;
                    r_sq = distsq(cen, cds[i]);
                }

                bool ok = true;
                for (int l = 0; l < N; ++l) {
                    double r_sqcan = distsq(cen, cds[l]);
                    if (r_sqcan > r_sq + 1e-9) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    ans = min(ans, r_sq);
                }
            }
        }
    }

    cout << setprecision(20) << sqrt(ans) << endl;

    return 0;
}

Measured memory_bytes: 256