#include <bits/stdc++.h>
  
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
 
using namespace std;
 
#if !ONLINE_JUDGE
#define debug
#endif
 
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> ii;
typedef vector<pair<int,int> > vii;
typedef pair<ll,ll> pll;
typedef vector<vector<int> > vvi;
typedef vector<vector<ii> > vvii;
 
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define fill(a,x) memset(a,x,sizeof(a))
#define ff first
#define ss second
#define trav(a, x) for(auto& a : x) 
#define FOR(i,a,b) for(int i = a; i<=b; ++i)
#define NFOR(i,a,b) for(int i = a; i>=b; --i)

#ifdef debug
#define dbg(...) { cerr<<"[ "; dump(#__VA_ARGS__, __VA_ARGS__);}
#undef endl
template <typename Arg1,typename Arg2>
ostream& operator << (ostream& out, const pair<Arg1,Arg2> &x) {
    return out<<"("<<x.ff<<","<<x.ss<<")";
}
 
template <typename Arg1>
ostream& operator << (ostream& out, const vector<Arg1> &a) {
    out<<"[";for(const auto &x:a)out<<x<<",";return out<<"]";
}
 
template <typename Arg1>
ostream& operator << (ostream& out, const set<Arg1> &a) {
    out<<"[";for(const auto &x:a)out<<x<<",";return out<<"]";
}
 
template <typename Arg1,typename Arg2>
ostream& operator << (ostream& out, const map<Arg1,Arg2> &a) {
    out<<"[";for(const auto &x:a)out<<x<<",";return out<<"]";
}
 
template <typename Arg1,typename Arg2>
ostream& operator << (ostream& out, const unordered_map<Arg1,Arg2> &a) {
    out<<"[";for(const auto &x:a)out<<x<<",";return out<<"]";
} 
 
template <typename Arg1>
void dump(const string name, Arg1&& arg1){
    cerr << name << " : " << arg1 << " ] " << endl;
}
 
template <typename Arg1, typename... Args>
void dump(const string names, Arg1&& arg1, Args&&... args){
    const string name = names.substr(0,names.find(','));
    cerr<<name<<" : "<<arg1<<" | ";
    dump(names.substr(1+(int)name.size()), args...);
}
#else
    #define dbg(args...)
#endif
 
ll gcd(ll a,ll b){if (a==0) return b;return gcd(b%a,a);}
ll lcm(ll a,ll b){return a*(b/gcd(a,b));}
ll Abs(ll a){if(a>0)return a;return -a;}
ll Ceil(ll a,ll b){if(a%b==0)return a/b;else return a/b+1;}
double Abs(double a){if(a>0)return a;return -a;}
 
//*X.find_by_order(2) element at index=2
//X.order_of_key(1) how many elements strictly less than 1
 
#define ordered_set tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update> 

const ll INF = 1e18;
const int mod = 1e9 + 7;
 
inline int pow_(ll x, ll y,ll p){
  int r = 1; while(y){if(y & 1) r = r * x % p; y >>= 1; x = x * x % p;} return r;
}
inline int inv_(int x){return pow_(x, mod - 2, mod);}
inline int add(ll a,ll b){a += b; if(a >= mod) a -= mod; return a;}
inline int mul(int a, int b){return a * 1LL * b % mod;}
inline int sub(int a, int b){a -= b; if(a < 0) a += mod; return a;}
  
mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
 
const int N = 1e5 + 5;

struct point{
    double x;
    double y;
};


double dist(double x1,double y1,double x2,double y2){
    return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}


point center_from(double bx, double by, double cx, double cy) {
    double B=bx*bx+by*by, C=cx*cx+cy*cy, D=bx*cy-by*cx;
    point X;
    X.x = (cy*B-by*C)/(2*D);
    X.y = (bx*C-cx*B)/(2*D);
    return X;
}

// This pair is used to store the X and Y 
// coordinate of a point respectively 
#define pdd pair<double, double> 
  
// Function to find the line given two points 
void lineFromPoints(pdd P, pdd Q, double &a, 
                        double &b, double &c) 
{ 
    a = Q.second - P.second; 
    b = P.first - Q.first; 
    c = a*(P.first)+ b*(P.second); 
} 
  
// Function which converts the input line to its 
// perpendicular bisector. It also inputs the points 
// whose mid-point lies on the bisector 
void perpendicularBisectorFromLine(pdd P, pdd Q, 
                 double &a, double &b, double &c) 
{ 
    pdd mid_point = make_pair((P.first + Q.first)/2, 
                            (P.second + Q.second)/2); 
  
    // c = -bx + ay 
    c = -b*(mid_point.first) + a*(mid_point.second); 
  
    double temp = a; 
    a = -b; 
    b = temp; 
} 
  
// Returns the intersection point of two lines 
pdd lineLineIntersection(double a1, double b1, double c1, 
                         double a2, double b2, double c2) 
{ 
    double determinant = a1*b2 - a2*b1; 
    if (determinant == 0) 
    { 
        // The lines are parallel. This is simplified 
        // by returning a pair of FLT_MAX 
        return make_pair(FLT_MAX, FLT_MAX); 
    } 
  
    else
    { 
        double x = (b2*c1 - b1*c2)/determinant; 
        double y = (a1*c2 - a2*c1)/determinant; 
        return make_pair(x, y); 
    } 
} 
  
pdd findCircumCenter(pdd P, pdd Q, pdd R) 
{ 
    // Line PQ is represented as ax + by = c 
    double a, b, c; 
    lineFromPoints(P, Q, a, b, c); 
  
    // Line QR is represented as ex + fy = g 
    double e, f, g; 
    lineFromPoints(Q, R, e, f, g); 
  
    // Converting lines PQ and QR to perpendicular 
    // vbisectors. After this, L = ax + by = c 
    // M = ex + fy = g 
    perpendicularBisectorFromLine(P, Q, a, b, c); 
    perpendicularBisectorFromLine(Q, R, e, f, g); 
  
    // The point of intersection of L and M gives 
    // the circumcenter 
    pdd circumcenter = 
           lineLineIntersection(a, b, c, e, f, g); 
  
    if (circumcenter.first == FLT_MAX && 
        circumcenter.second == FLT_MAX) 
    { 
        // cout << "The two perpendicular bisectors "
        //         "found come parallel" << endl; 
        // cout << "Thus, the given points do not form "
        //         "a triangle and are collinear" << endl; 
        return pdd(-1e9,-1);
    } 
  
    else
    { 
        return circumcenter;
        // cout << "The circumcenter of the triangle PQR is: "; 
        // cout << "(" << circumcenter.first << ", "
        //      << circumcenter.second  << ")" << endl; 
    } 
} 

double EPS = 1e-8;

int main(int argc, char const *argv[])
{
    #ifdef LOCAL_TEST
    freopen("in.txt","r",stdin);
    //freopen("out.txt", "w", stdout);
    #else
    ios_base::sync_with_stdio(false);cin.tie(NULL);
    #endif

    auto start = std::chrono::high_resolution_clock::now();

    int n;
    cin>>n;
    vector<pair<double,double> > v;
    for(int i=1;i<=n;i++){
        double x,y;
        cin>>x>>y;
        v.pb({x,y});
    }

    double ans = INF;

    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            double x = (v[i].ff + v[j].ff)/2.0;
            double y = (v[i].ss + v[j].ss)/2.0;
            double r = dist(v[i].ff,v[i].ss,x,y);
            int flag = 1;
            for(int k=0;k<n;k++){
                int x1 = v[k].ff;
                int y1 = v[k].ss;
                if(dist(x1,y1,x,y) > r + EPS){
                    flag = 0;
                }
            }

            if(flag){
                ans = min(ans,r);
            }
        }
    }


    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            for(int k=j+1;k<n;k++){
                pair<double,double> D = findCircumCenter(v[i],v[j],v[k]);
                double r = dist(v[i].ff,v[i].ss,D.ff,D.ss);
                int flag = 1;
                for(int l=0;l<n;l++){
                    int x1 = v[l].ff;
                    int y1 = v[l].ss;
                    if(dist(x1,y1,D.ff,D.ss) > r + EPS){
                        flag = 0;
                    }
                }

                if(flag){
                    ans = min(ans,r);
                }
            }
        }
    }

    printf("%0.15f\n", ans);

    auto finish = std::chrono::high_resolution_clock::now();  
    std::chrono::duration<double> elapsed = finish - start;
    cerr << "Elapsed time: " << elapsed.count() << " s\n";
    
    return 0;    
}

Measured memory_bytes: 256