#include<bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
 
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
 
#define start_routine() int begtime = clock();
#define end_routine() int endtime = clock(); cerr << endl << "Time elapsed: " << (endtime - begtime)*1000/CLOCKS_PER_SEC << " ms"; return 0
#define speed() cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
// #define exit(a, b) return cout << a, b;
 
// debugger
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#define debug(stuff) cout << #stuff << ": " << stuff <<endl
#define debugc(stuff) cout << #stuff << ": "; for(auto x: stuff) cout << x << " "; cout << endl;
// 
 
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define all(v) v.begin(), v.end() 
 
#define print(stuff) cout << stuff << endl
#define printc(stuff) for(auto x: stuff) cout << x << " "; cout << endl;
#define printPrec(stuff) cout << fixed << setprecision(15) << stuff << endl;
#define len length
#define ret0 return 0
#define ret return 
 
 
#define ll long long
#define ld long double
#define fi first
#define endl '\n'
#define se second
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define fill(ar, x) memset(ar, x, sizeof ar)
 
#define vl vector<ll> 
#define sl set<ll>
#define pll pair<ll, ll>
#define mll map<ll, ll> 
#define pq priority_queue<ll>
 
// typedef tree<ll,null_type,less<ll>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
 
#define inf (long long int) 1e18
#define eps 0.000001
#define mod 1000000007
#define mod1 998244353
#define MAXN (ll)2e5+5
#define N (1ll<<10)
#define pi 3.141592653589793238462643

template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    long double dist() const { return sqrt((double)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
};


void lineFromPoints(Point<ld> pp, Point<ld> Q, double &a, double &b, double &c) { 
    a = Q.y - pp.y; 
    b = pp.x - Q.x; 
    c = a*(pp.x)+ b*(pp.y); 
} 
void perpendicularBisectorFromLine(Point<ld> pp, Point<ld> Q, double &a, double &b, double &c) { 
    Point<ld> mid_point((pp.x + Q.x)/2, (pp.y + Q.y)/2); 
    c = -b*(mid_point.x) + a*(mid_point.y); 
    double temp = a; 
    a = -b; 
    b = temp; 
} 
Point<ld> lineLineIntersection(double a1, double b1, double c1, double a2, double b2, double c2) { 
    Point<ld> ree;
    double determinant = a1*b2 - a2*b1; 
    if (determinant == 0) { 
        ree.x = FLT_MAX, ree.y = FLT_MAX;
        ret ree; 
    } 
    else{ 
        double xxx = (b2*c1 - b1*c2)/determinant; 
        double yyy = (a1*c2 - a2*c1)/determinant; 
        ree.x = xxx;
        ree.y = yyy;
    } 
    ret ree;
} 
Point<ld> findCircumCenter(Point<ld> pp, Point<ld> Q, Point<ld> R) { 
    double a, b, c; 
    lineFromPoints(pp, Q, a, b, c); 
    double e, f, g; 
    lineFromPoints(Q, R, e, f, g); 
    perpendicularBisectorFromLine(pp, Q, a, b, c); 
    perpendicularBisectorFromLine(Q, R, e, f, g); 
    Point<ld> circumcenter = 
    lineLineIntersection(a, b, c, e, f, g); 
    if (circumcenter.x == FLT_MAX && circumcenter.y == FLT_MAX) { 
        return circumcenter;
    } 
    else { 
        return circumcenter;
    } 
    return circumcenter;
} 


void solve(){
    ll n;
    cin>>n;

    Point<ld> pp[n];


    loop(i,0,n){
        cin>>pp[i].x>>pp[i].y;
    }
    
    ld ans = inf;

    for(ll i=0; i<n; i++){
        for(ll j=i+1; j< n; j++){
            Point<ld> circen;
            circen.x = (pp[i].x + pp[j].x)/2;
            circen.y = (pp[i].y + pp[j].y)/2;
            ld val = -inf;
            for(ll l = 0; l < n; l++){
                val = max(val, (circen-pp[l]).dist());
            }
            ans = min(ans, val);
        }
    }
    for(ll i=0; i<n; i++){
        for(ll j=i+1; j < n; j++){
            for(ll k=j+1; k < n; k++){
                Point<ld> circen = findCircumCenter(pp[i], pp[j], pp[k]);
                if(circen.x != FLT_MAX && circen.y != FLT_MAX){
                    ld val = -inf;
                    for(ll l = 0; l < n; l++){
                        val = max(val, (circen-pp[l]).dist());
                    }
                    ans = min(ans, val);
                }
                
            }
        }
    }

    printPrec(ans);

}
 
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
  
 
    ll t = 1;
    // cin>>t;
    while(t--){
        solve();
    }
    

}


Measured memory_bytes: 256