/*enjoy karo yaar*/

//CF,CC,AtC,SPOJ: hp1999
//HE: hemant269
//HR: hemant2132

#include<bits/stdc++.h>
using namespace std;

#define     int          long long int
#define     ld           long double
#define     fast()       ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define     all(x)       x.begin(),x.end()
#define     mem(a,b)     memset(a,b,sizeof(a))
#define     gcd(a,b)     (__gcd((a),(b)))
#define     lcm(a,b)     (((a)*(b))/gcd((a),(b)))
#define     pb           push_back
#define     ins          insert
#define     pii          pair<int,int>
#define     x            first
#define     y            second
#define     show(x)      for(auto c:x)cout<<c<<" ";cout<<"\n";

const int inf=1e9,M=1e9+7;
const int N=1;

#define pdd pair<ld, ld>

// Function to find the line given two points
void lineFromPoints(pdd P, pdd Q, ld &a,
                        ld &b, ld &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,
                 ld &a, ld &b, ld &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);

    ld temp = a;
    a = -b;
    b = temp;
}

// Returns the intersection point of two lines
pdd lineLineIntersection(ld a1, ld b1, ld c1,
                         ld a2, ld b2, ld c2)
{
    ld 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
    {
        ld x = (b2*c1 - b1*c2)/determinant;
        ld 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
    ld a, b, c;
    lineFromPoints(P, Q, a, b, c);

    // Line QR is represented as ex + fy = g
    ld 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);

    return circumcenter;
}

ld f(ld x,ld y)
{
    ld res=x*x+y*y;
    return res;
}

void solve()
{
    cout<<fixed<<setprecision(10);

    int n;
    cin>>n;

    vector<pair<ld,ld>> v(n);
    for(int i=0;i<n;++i)
        cin>>v[i].x>>v[i].y;

    ld ans=inf;
    pair<ld,ld> a,b,c,circ;
    ld mx;

    for(int i=0;i<n;++i)
    {
        for(int j=i+1;j<n;++j)
        {
            circ.x=(v[i].x+v[j].x)/2;
            circ.y=(v[i].y+v[j].y)/2;

            mx=0;
            for(int k=0;k<n;++k)
                mx=max(mx,f(circ.x-v[k].x,circ.y-v[k].y));

            ans=min(ans,mx);
        }
    }

    for(int i=0;i<n;++i)
    {
        for(int j=i+1;j<n;++j)
        {
            for(int k=j+1;k<n;++k)
            {
                a=v[i],b=v[j],c=v[k];

                circ=findCircumCenter(a,b,c);

                if(circ.x==FLT_MAX && circ.y==FLT_MAX)
                    continue;

                mx=0;
                for(int l=0;l<n;++l)
                    mx=max(mx,f(circ.x-v[l].x,circ.y-v[l].y));

                ans=min(ans,mx);
            }
        }
    }

    ans=sqrt(ans);
    cout<<ans;
}

int32_t main()
{
    fast();

    int t=1;
    //cin>>t;
    while(t--)
    {
        solve();
        //cout<<"\n";
    }

    return 0;
}



Measured memory_bytes: 256