#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);
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>(INF, INF);
	return ans.second;
}
// void _minEnclosing(Point<LD> &c, LD &radius, vector<Point<LD>> &pnts, vector<Point<LD>> &border, int &nbPnts, int &nbBorder) {
// 	if (nbBorder == 3) c = getCircleCenter(border[0], border[1], border[2]), radius = c.dist(border[0]);
// 	else if (nbPnts == 0 && nbBorder <= 1) c = border[0], radius = c.dist(border[0]);
// 	else if (nbPnts == 0 && nbBorder == 2) c = ((border[0] + border[1])*0.5L), radius = c.dist(border[0]);
// 	else {
// 		nbPnts--;
// 		_minEnclosing(c, radius, pnts, border, nbPnts, nbBorder);
// 		if (c.dist(pnts[nbPnts]) > radius) {
// 			border[nbBorder++] = pnts[nbPnts];
// 			_minEnclosing(c, radius, pnts, border, nbPnts, nbBorder);
// 			nbBorder--;
// 		}
// 		nbPnts++;
// 	}
// }
// pair<Point<LD>,LD> minEnclosingCircle(vector<Point<LD>> &pnts){
// 	mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// 	shuffle(all(pnts), rng);

// 	int nbPnts = size(pnts), nbBorder = 0;
// 	vector<Point<LD>> border(3);
// 	Point<LD> c; LD radius;
// 	_minEnclosing(c, radius, pnts, border, nbPnts, nbBorder);
// 	return {c, radius};
// }

int n; LD r = INF;
Point<LD> pnts[NN+3];

int main(){ FAST;
	cin >> n;
	for(int i=1; i<=n; ++i) cin >> pnts[i].X >> pnts[i].Y;

	for(int i=1; i<=n; ++i)
	for(int j=i+1; j<=n; ++j){
		Point<LD> c = (pnts[i] + pnts[j]) * 0.5L;
		LD tmpR = 0.0L;
		for(int ind=1; ind<=n; ++ind) tmpR = max(tmpR, c.dist(pnts[ind]));
		r = min(r, tmpR);
	}

	for(int i=1; i<=n; ++i)
	for(int j=i+1; j<=n; ++j)
	for(int k=j+1; k<=n; ++k){
		Point<LD> c = getCircleCenter(pnts[i], pnts[j], pnts[k]);
		LD tmpR = 0.0L;
		for(int ind=1; ind<=n; ++ind) tmpR = max(tmpR, c.dist(pnts[ind]));
		r = min(r, tmpR);
	}

	cout << fixed << setprecision(16) << r << ln;
}

Measured memory_bytes: 256