#include<algorithm>
#include<bitset>
#include<cassert>
#include<cfloat>
#include<climits>
#include<cmath>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>

using namespace std;

using lint = long long;
using P = pair<int, int>;
using LLP = pair<long long, long long>;

#define REP(i, x, n) for(int i = (x), i##_len = (int)(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = (int)(n) ; i < i##_len ; ++i)
#define reps(i, n) for(int i = 1, i##_len = (int)(n) ; i <= i##_len ; ++i)
#define rrep(i, n) for(int i = (int)(n) - 1 ; i >= 0 ; --i)
#define rreps(i, n) for(int i = (int)(n) ; i > 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
#define REVERSE(x) reverse((x).begin(), (x).end())
#define TWINS(x) cout << ((x) ? "Yay!" : ":(") << '\n'
#define endl '\n'

constexpr int IINF = (1 << 30) - 1;
constexpr long long LLINF = 1LL << 61;
constexpr double EPS = 1e-10;

constexpr int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
constexpr int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};

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

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

inline double dist2(double x1, double y1, double x2, double y2){
    return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
}

inline double dist(double x1, double y1, double x2, double y2){
    return sqrt(dist2(x1, y1, x2, y2));
}

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

    int n;
    cin >> n;

    vector<double> x(n), y(n);
    vector<int> X(n), Y(n);
    rep(i, n){
        cin >> X[i] >> Y[i];
        x[i] = X[i];
        y[i] = Y[i];
    }

    double ans = 1e18;

    rep(i, n){
        rep(j, i){
            double px = (x[i]+x[j])*0.5;
            double py = (y[i]+y[j])*0.5;
            double r2 = dist2(px, py, x[i], y[i]);

            bool ok = true;
            rep(k, n){
                if(dist2(px, py, x[k], y[k]) < r2 || abs(dist2(px, py, x[k], y[k])-r2) < EPS){
                    continue;
                }else{
                    ok = false;
                    break;
                }
            }

            if(ok){
                chmin(ans, sqrt(r2));
            }
        }
    }

    rep(i, n){
        rep(j, i){
            rep(k, j){
                double a = x[i];
                double b = y[i];
                double c = x[j];
                double d = y[j];
                double e = x[k];
                double f = y[k];

                if(abs(dist(a, b, c, d)+dist(c, d, e, f)-dist(a, b, e, f)) < EPS || abs(dist(a, b, e, f)+dist(e, f, c, d)-dist(a, b, c, d) < EPS) || abs(dist(c, d, a, b)+dist(a, b, e, f)-dist(c, d, e, f)) < EPS){
                    continue;
                }

                double py = ((e-a)*(a*a+b*b-c*c-d*d)-(c-a)*(a*a+b*b-e*e-f*f))/(2.0*(e-a)*(b-d)-2.0*(c-a)*(b-f));
                double px;
                if(X[i] == X[j]){
                    px = (2.0*(b-f)*py-a*a-b*b+e*e+f*f)/(2.0*(e-a));
                }else{
                    px = (2.0*(b-d)*py-a*a-b*b+c*c+d*d)/(2.0*(c-a));
                }
                double r2 = dist2(px, py, a, b);

                bool ok = true;
                rep(l, n){
                    if(dist2(px, py, x[l], y[l]) < r2 || abs(dist2(px, py, x[l], y[l]) - r2) < EPS){
                        continue;
                    }else{
                        ok = false;
                        break;
                    }
                }
                if(ok){
                    chmin(ans, sqrt(r2));
                }
            }
        }
    }

    cout << ans << endl;

    cout << flush;

    return 0;
}

Measured memory_bytes: 384