#include <iostream>
#include <sstream>
#include <stack>
#include <iomanip>
#include <numeric>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <cmath>

#define BEGIN(x) x.begin()
#define END(x) x.end()
#define ALL(x) BEGIN(x), END(x)
#define PAIR make_pair
#define VEC(type) vector<type >
#define endl '\n'

#define FOR(i, A, B) for(auto i = (A);i != (B); i++)
#define FORD(i, A, B) for(auto i = (A);i != (B); i--)

#define READRANGE(begin, end) FOR(it, begin, end) cin >> *it
#define READVEC(V) READRANGE(BEGIN(V), END(V))

using namespace std;

typedef long long lint;
typedef pair<int, int> Pii;
typedef pair<int, lint> Pil;
typedef pair<lint, lint> Pll;
typedef pair<lint, int> Pli;

template<class U, class V>
istream& operator >>(istream& in, pair<U, V>& pr) {
    return in >> pr.first >> pr.second;
}

template<class U, class V>
ostream& operator <<(ostream& out, pair<U, V>& p) {
    return out << p.first << " " << p.second;
}

template<class T>
ostream& operator <<(ostream& out, vector<T> vec) {
    for (T& e : vec)
        out << e << " ";
    return out << endl;
}

// ---- BEGIN LIBRARY CODE ----
// ---- END LIBRARY CODE ----
void io_init()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
};

const double EPS = 1e-9;

double pointDist(double x0, double y0, double x1, double y1)
{
    double dx = x0 - x1, dy = y0 - y1;
    return sqrt(dx * dx + dy * dy);
};

// Vector's x and y components are given.
vector<pair<double, double> > rotate(double x, double y, double mag)
{
    vector<pair<double, double> > ret(2);
    if (mag <= EPS) {
        ret[1] = ret[0] = {0, 0};
        return ret;
    }

    double fac = pointDist(0, 0, x, y) / mag;
    ret[0] = {(-y) / fac, x / fac};
    ret[1] = {y / fac, (-x) / fac};
    return ret;
};

bool checkPoint(VEC(double)& X, VEC(double)& Y, double R, 
            double x0, double y0)
{
    const int N = X.size();
    FOR(i, 0, N) {
        double dx = x0 - X[i], dy = y0 - Y[i];
        if ((dx * dx + dy * dy) >= R * R + EPS)
            return false;
    }

    return true;
};

bool check(VEC(double)& X, VEC(double)& Y, double R)
{
    const int N = X.size();
    FOR(i, 0, N)
        if (checkPoint(X, Y, R, X[i], Y[i]))
            return true;

    FOR(i, 0, N)
        FOR(j, i + 1, N) {

            double x1 = X[i], y1 = Y[i];
            double x2 = X[j], y2 = Y[j];
            if (pointDist(x1, y1, x2, y2) >= 2 * R + EPS)
                return false;

            double xmid = (x1 + x2) / 2.0, ymid = (y1 + y2) / 2.0;
            double vx = xmid - x1, vy = ymid - y1;

            double dHalf = 0.5 * pointDist(x1, y1, x2, y2);
            double mag = sqrt(R * R - dHalf * dHalf);

            vector<pair<double, double> > vt = rotate(vx, vy, mag);
            for (auto pt : vt) {
                double xcand = xmid + pt.first;
                double ycand = ymid + pt.second;
                if (checkPoint(X, Y, R, xcand, ycand))
                    return true;
            }
        }

    return false;
};

int main(int argc, char **argv)
{
    io_init();

    // Actual program code starts here.
    int N;
    cin >> N;
    VEC(double) X(N), Y(N);
    FOR(i, 0, N)
        cin >> X[i] >> Y[i];

    double lo = 0, hi = 10000;
    int iters = 0;
    while (++iters <= 150 && hi - lo > EPS) {
        double mid = (lo + hi) / 2.0;
        if (check(X, Y, mid))
            hi = mid;
        else
            lo = mid;
    }

    double ret = lo;
    cout << fixed << setprecision(10) << ret << endl;
    return 0;
};

Measured memory_bytes: 384