#include "bits/stdc++.h"
using namespace std;
void __dump(int x){cerr << x;}
void __dump(long long x){cerr << x;}
void __dump(long double x){cerr << fixed << setprecision(3) << x;}
void __dump(char x){cerr << '\'' << x << '\'';}
void __dump(const string &x){cerr << '"' << x << '"';}
void __dump(const char *x){cerr << '"' << x << '"';}
void __dump(bool x){cerr << (x ? "true" : "false");}
void _dump(){cerr << "\n";}
template <typename T, typename U> void __dump(const pair<T, U> &x){cerr << '{'; __dump(x.first); cerr << ','; __dump(x.second); cerr << '}';}
template <typename T, typename U, typename V> void __dump(const tuple<T, U, V> &x){cerr << '{'; __dump(get<0>(x)); cerr << ',';  __dump(get<1>(x)); cerr << ',';  __dump(get<2>(x)); cerr << '}';}
template <typename T> void __dump(const T& x){int f=0; cerr << '{'; for(auto&i:x) cerr << (f++ ? "," : ""), __dump(i); cerr << "}";}
template <typename T, typename ... U> void _dump(T t, U ... u){__dump(t); if(sizeof...(u)) cerr << ", "; _dump(u...);}
#define dump(x ...) cerr  <<  "|| "  <<  # x  <<  "  =  ", _dump(x) 
//#define int long long
#define FAST ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define size(x) (int)x.size()
#define all(x) x.begin(),x.end()
#define ln '\n'
#define __ ' '
#define LL long long
#define LD long double
#define pii pair<int,int>
const int INF = 2e9;
const int NN = 50;
const LD EPS = 1e-8L;
const LD PI = acos(-1.0L);
const LL INFLL = 1e18L;
inline bool eq(const LD &a, const LD &b){return fabs(a-b) < EPS;}
inline bool lt(const LD &a, const LD &b){return fabs(a-b) > EPS && a < b;}
inline bool gt(const LD &a, const LD &b){return fabs(a-b) > EPS && a > b;}
#define lte(a,b) (!gt(a,b))
#define gte(a,b) (!lt(a,b))
template<typename T> struct Point {
	#define Vector Point
	T X, Y;
	Point(){}
	Point(const Point &oth){ X = oth.X; Y = oth.Y; }
	Point(T _X, T _Y): X(_X), Y(_Y){}
    bool operator==(const Point &oth) { return eq(X, oth.X) && eq(Y, oth.Y); }
	bool operator!=(const Point &oth) { return !eq(X, oth.X) || !eq(Y, oth.Y); }
	Point operator+(const Point &oth) { return Point( X + oth.X, Y + oth.Y ); }
    Point operator-(const Point &oth) { return Point( X - oth.X, Y - oth.Y ); }
    T operator*(const Point &oth) { return X * oth.X + Y * oth.Y; }
    T operator%(const Point &oth) { return X * oth.Y - Y * oth.X; }
    Point operator*(T f) { return Point( X * f, Y * f ); }
	T norm() { return sqrtl((LD)X*X + Y*Y); }
	T dist(const Point &oth) { return (*this - oth).norm(); }	
	Vector perpendicular() { return Vector(Y, -X); }
	bool ccw(const Point &a, const Point &b) { return gte((*this-a)%(*this-b), 0); }
	LD angle() { LD ang = atan2(Y, X); return lt(ang, 0) ? ang+2.L*PI : ang; }
	bool insideLine(const Point &a, const Point &b){ return eq(0, (*this-a)%(*this-b)); }
	bool insideSegment(const Point &a, const Point &b) { return insideLine(a,b) && ((gte(a.X,X)&&gte(X,b.X)) || (gte(b.X,X)&&gte(X,a.X))); }
};
pair<bool,Point<LD>> intersectLines(const Point<LD> &a, const Point<LD> &b, const Point<LD> &c, const Point<LD> &d) {
	LD A1 = b.Y - a.Y, B1 = a.X - b.X, C1 = A1 * a.X + B1 * a.Y;
	LD A2 = d.Y - c.Y, B2 = c.X - d.X, C2 = A2 * c.X + B2 * c.Y;
	LD determinant = A1 * B2 - A2 * B1;
	Point<LD> ans;
	if(eq(determinant, 0)) return {false, ans};   // parallel
	ans = Point<LD>((B2 * C1 - B1 * C2) /determinant, (A1 * C2 - A2 * C1) /determinant);
	return {true, ans};
}
Point<LD> getCircleCenter(Point<LD> &a, Point<LD> &b, Point<LD> &c){  // 3 NON COLINEAR POINTS
	Point<LD> ab = (a + b) * 0.5L;
	Point<LD> ab2 = ab + (b - a).perpendicular();
	Point<LD> bc = (b + c) * 0.5L;
	Point<LD> bc2 = bc + (c - b).perpendicular();
	auto ans = intersectLines(ab, ab2, bc, bc2);
	if(!ans.first) return Point<LD>(INFLL, INFLL);
	return ans.second;
}

int n;
vector<Point<LD>> pnts;

pair<Point<LD>,LD> minEnclosingCircle(){
	Point<LD> c; LD r = INFLL;
	for(int i=0; i<size(pnts); ++i) for(int j=i+1; j<size(pnts); ++j){
		Point<LD> tmpC = (pnts[i] + pnts[j]) * 0.5L;
		LD tmpR = 0.0L;
		for(int ind=0; ind<size(pnts); ++ind) tmpR = max(tmpR, tmpC.dist(pnts[ind]));
		if(lt(tmpR,r)) r = tmpR, c = tmpC;
	}
	for(int i=0; i<size(pnts); ++i) for(int j=i+1; j<size(pnts); ++j) for(int k=j+1; k<size(pnts); ++k){
		Point<LD> tmpC = getCircleCenter(pnts[i], pnts[j], pnts[k]);
		LD tmpR = 0.0L;
		for(int ind=0; ind<size(pnts); ++ind) tmpR = max(tmpR, tmpC.dist(pnts[ind]));
		if(lt(tmpR,r)) r = tmpR, c = tmpC;
	}
	return {c, r};
}

int main(){ FAST;
	cin >> n;
	for(int i=1; i<=n; ++i){
		LD x,y; cin >> x >> y;
		pnts.emplace_back(Point<LD>(x,y));
	}

	cout << fixed << setprecision(16) << minEnclosingCircle().second << ln;
}

Measured memory_bytes: 256