#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
using namespace std;
typedef long long int ll;
typedef pair<int,int> PP;
#define yn {puts("Yes");}else{puts("No");}
#define MAX_N 200005

double EPS = 1e-10;

double add(double a, double b){
    if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
    return a + b;
}

struct P {
    double x, y;
    P() {}
    P(double x, double y) : x(x), y(y) {

    }
    P operator + (P p) {
        return P(add(x, p.x), add(y, p.y));
    }
    P operator - (P p) {
        return P(add(x, -p.x), add(y, -p.y));
    }
    P operator * (double d) {
        return P(x * d, y * d);
    }
    double dot(P p) { // 内積
        return add(x * p.x, y * p.y);
    }
    double det(P p) { // 外積
        return add(x * p.y, -y * p.x);
    }
};

bool cmp_x(const P& p, const P& q) {
    if (p.x != q.x) return p.x < q.x;
    return p.y < q.y;
}

vector<P> convex_hull (P* ps, int n) {
    sort(ps, ps + n, cmp_x);
    int k = 0;
    vector<P> qs(n * 2);
    // 下側凸包の作成
    for (int i = 0; i < n; i++) {
        while (k > 1 && (qs[k - 1] - qs[k - 2]).det(ps[i] - qs[k - 1]) <= 0) k--;
        qs[k++] = ps[i];
    }
    // 上側凸包の作成
    for (int i = n - 2, t = k; i >= 0; i--) {
        while (k > t && (qs[k - 1] - qs[k - 2]).det(ps[i] - qs[k - 1]) <= 0) k--;
        qs[k++] = ps[i];
    }
    qs.resize(k - 1);
    return qs;
}

vector<double> calc(double x[], double y[]){
    int n = 3;
    double a, b, alpha, beta, gamma, delta;
    alpha = add(x[0], -x[1]); beta = add(y[0], -y[1]);
    gamma = add(x[1], -x[2]); delta = add(y[1], -y[2]);
    double norm[n];
    rep(i,n)norm[i] = add(x[i] * x[i], y[i] * y[i]);

    a = 1.0 / 2.0 / add(alpha * delta, -beta * gamma) * (delta * (norm[0] - norm[1]) + -beta * (norm[1] - norm[2]));
    b = 1.0 / 2.0 / add(alpha * delta, -beta * gamma) * (-gamma * (norm[0] - norm[1]) + alpha * (norm[1] - norm[2]));

    vector<double> res(3);
    res[0] = a, res[1] = b;
    res[2] = sqrt((x[0]-a)*(x[0]-a)+(y[0]-b)*(y[0]-b));
    return res;
}


int main() {
    int n;
    cin >> n;
    P ps[n];
    rep(i,n)cin >> ps[i].x >> ps[i].y;

    vector<P> qs = convex_hull(ps, n);
    int m = qs.size();

    double ans = 1e18;
    if(m == 2){
        ans = sqrt(pow(qs[0].x-qs[1].x, 2) + pow(qs[0].y - qs[1].y, 2)) / 2.0;
        cout << fixed << setprecision(10) << ans << endl;
        return 0;
    }

    rep(i,m){
        srep(j,i+1,m){
            srep(k,j+1,m){
                double x[3], y[3];
                x[0] = qs[i].x, y[0] = qs[i].y;
                x[1] = qs[j].x, y[1] = qs[j].y;
                x[2] = qs[k].x, y[2] = qs[k].y;
                vector<double> tmp = calc(x, y);
                double a = tmp[0];
                double b = tmp[1];
                double r = tmp[2];
                int flag = 1;
                rep(l,m){
                    if(sqrt(pow(qs[l].x-a, 2) + pow(qs[l].y - b, 2)) - r >= EPS) flag = 0;
                }
                if(flag) ans = min(ans, r);
            }
        }
    }

    rep(i,m){
        srep(j,1,m){
            double a = (qs[i].x + qs[j].x) / 2.0;
            double b = (qs[i].y + qs[j].y) / 2.0;
            double r = sqrt(pow(qs[i].x-qs[j].x, 2) + pow(qs[i].y - qs[j].y, 2)) / 2.0;
            int flag = 1;
            rep(k,m){
                if(sqrt(pow(qs[k].x-a, 2) + pow(qs[k].y - b, 2)) - r >= EPS) flag = 0;
            }
            if(flag) ans = min(ans, r);
        }
    }

    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}




Measured memory_bytes: 256