// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define SIZE 300005
#define MOD 1000000007LL
#define EPS 1e-10
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define REP(i,n) for(int i=0;i<n;i++)
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define DOWN(i,b,a) for(int i=b;i>=a;i--)
#define SET(a,c) memset(a,c,sizeof a)
#define BIT(i,j) ((i)>>(j))&1
#define ALL(o) (o).begin(), (o).end()
#define ERASE(o) (o).erase(unique((o).begin(),(o).end()), (o).end())
#define SQ(x) ((x)*(x))
using namespace std;
typedef int_fast64_t ll;
typedef pair<ll,ll> Pll;
typedef pair<int, int> Pii;
typedef pair<double, double> Pdd;
typedef complex<double> dcomplex;
template<typename T> inline void priv(vector<T>a){REP(i,a.size()){cerr<<a[i]<<((i==a.size()-1)?"\n":" ");}}
inline void fastio(){cin.tie(nullptr); cout.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(15);}
ll gcd(ll a,ll b){ll c=max(a,b);ll d=min(a,b);return c==0||d==0?c:gcd(c%d,d);}
ll lcm(ll a,ll b){return a==0||b==0?0:a*b/gcd(a,b);}
ll modfact(ll a){ll b=1;FOR(i,2,a)b=b*i%MOD;return b;}
ll modpow(ll a, ll n){ll b=1;while (n>0){if(n&1)b=b*a%MOD;a=a*a%MOD;n>>=1;}return b;}
ll modcomb(ll n, ll k){ll b=1;k=min(n-k,k);DOWN(i,n,n-k+1)b=b*i%MOD;return b*modpow(modfact(k),MOD-2)%MOD;}

class Point {
public:
    double x, y;
    Point(){};Point(double x,double y):x(x),y(y){};
    Point &operator+=(const Point&q){x+=q.x;y+=q.y;return *this;}
    Point &operator-=(const Point&q){x-=q.x;y-=q.y;return *this;}
    Point operator+(const Point&q){Point t;t.x=x+q.x;t.y=y+q.y;return t;}
    Point operator-(const Point&q){Point t;t.x=x-q.x;t.y=y-q.y;return t;}
    template<typename T> Point &operator*=(T d){x*=d;y*=d;return *this;}
    template<typename T> Point &operator/=(T d){x/=d;y/=d;return *this;}
    template<typename T> Point operator*(T d){return Point(x*d,y*d);}
    template<typename T> Point operator/(T d){return Point(x/d,y/d);}
    bool operator<(const Point&q)const{return (x!=q.x)?(x<q.x):(y<q.y);}
    bool operator>(const Point&q)const{return (x!=q.x)?(x>q.x):(y>q.y);}
    double norm(void){return sqrt(x*x+y*y);}
    double arg(void){return acos(x/this->norm())*Point(1,0).sign(*this);}
    Point rotate(double t){double c=cos(t),s=sin(t);return Point(c*x-s*y,s*x+c*y);}
    Point nvec(void){return Point(y,-x);}
    Point reverseX(void){return Point(-x,y);}
    Point reverseY(void){return Point(x,-y);}
    Point unit(void){return (*this).norm()==0?Point(0,0):(*this)/(*this).norm();}
    Point floor(void){return Point((int)x,(int)y);}
    double dot(const Point&q){return x*q.x+y*q.y;}
    double det(const Point&q){return x*q.y-y*q.x;}
    int sign(const Point&q){double d = (*this).det(q); return (d>0)-(d<0);}
    static bool on_seg(Point p1,Point p2,Point q){return (p1-q).det(p2-q)==0&&(p1-q).dot(p2-q)<=0;}
    static Point intersection(Point p1,Point p2,Point q1,Point q2){return p1+(p2-p1)*((q2-q1).det(q1-p1)/(q2-q1).det(p2-p1));}
    static bool crossing(Point p1,Point p2,Point q1,Point q2) {
        if((p2-p1).sign(q2-q1)==0) return on_seg(p1,p2,q1)||on_seg(p1,p2,q2)||on_seg(q1,q2,p1)||on_seg(q1,q2,p2);
        double x=(q2-q1).det(q1-p1)/(q2-q1).det(p2-p1);
        double y=(p2-p1).det(p1-q1)/(p2-p1).det(q2-q1);
        return x<=1 && x>=0 && y<=1 && y>=0;
    }
};

ll N;
double x, y, eps=1e-10;
vector<Point> P;

inline bool judge(double r) {
    vector<Point> ps;
    REP(i, N) FOR(j, i+1, N-1){
        Point vec = P[j] - P[i];
        double l = vec.norm();
        double h = sqrt(r*r - l*l * 0.25);
        Point base = (P[i] + P[j]) * 0.5;
        Point dir = vec.nvec() * (h / l);
        ps.push_back(base + dir);
        ps.push_back(base - dir);
    }
    bool f;
    for(auto &p : ps) {
        f = true;
        REP(i, N) {
            if((p-P[i]).norm() > (r + eps)) {
                f = false;
                break;
            }
        }
        if(f) return true;
    }
    return false;
}

double solve() {
    double l = 0;
    FOR(i, 0, N-1) FOR(j, 1, N-1)
        l = max(l, (P[i]-P[j]).norm() * 0.5);
    double r = 1500, m;
    while(r - l > eps) {
        m = (r + l) * 0.5;
        if(judge(m)) r = m;
        else l = m;
    }
    return r;
}

int main() {
    fastio();
    cin >> N;
    P.resize(N);
    REP(i, N) {
        cin >> x >> y;
        P[i] = Point(x, y);
    }
    cout << solve() << endl; 
	return 0;
}

Measured memory_bytes: 428