// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



using lint = long long;



constexpr long double eps = 1e-4;



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; }

	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)); }

};



using P = Point<double>;

vector<P> points;



double dist(double x, double y) {

	double furthest = 0.0;

	for (int i = 0; i < points.size(); ++i) {

		double d = (x - points[i].x) * (x - points[i].x) 

		+ (y - points[i].y) * (y - points[i].y);

		furthest = max(furthest, sqrt(d));

	}

	return furthest;

}



double ts(double x) {

	double left = -1010, right = 1010;

	for (int i = 0; i <= 100; ++i) {

		double lmid = (2 * left + right)/3.0;

		double rmid = (left + 2 * right)/3.0;

		if (dist(x, lmid) > dist(x, rmid)) left = lmid;

		else right = rmid;

	}

	return dist(x, left);

}



int main() {

    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    int n;

    cin >> n;

    points.resize(n);

    for (int i = 0; i < n; ++i) cin >> points[i].x >> points[i].y;

    double left = -1010, right = 1010;

	for (int i = 0; i <= 100; ++i) {

		double lmid = (2 * left + right)/3.0;

		double rmid = (left + 2 * right)/3.0;

		if (ts(lmid) > ts(rmid)) left = lmid;

		else right = rmid;

	}

	cout << setprecision(10) << fixed << ts(left) << '\n';

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;



using lint = long long;



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; }

	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)); }

};

using P = Point<double>;



vector<P> pts;



double distance(double x, double y) {

	double furthest = 0.0;

	for (int i = 0; i < pts.size(); ++i) {

		double d = (x - pts[i].x) * (x - pts[i].x) + (y - pts[i].y) * (y - pts[i].y);

		furthest = max(furthest, d);

	}	

	return furthest;

}



double ts(double x) {

	double left = -1000, right = 1000;

	for (int i = 0; i <= 100; ++i) {

		double lmid = (2*left + right)/3.0;

		double rmid = (left + 2*right)/3.0;

		if (distance(x, lmid) > distance(x, rmid)) left = lmid;

		else right = rmid;

	}

	return distance(x, left);

}



int main() {

    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    int n;

    cin >> n;

    pts.resize(n);

    for (int i = 0; i < n; ++i) 

    	cin >> pts[i].x >> pts[i].y;

    double left = -1000, right = 1000;

    for (int i = 0; i <= 100; ++i) {

    	double lmid = (2*left + right)/3.0;

    	double rmid = (left + 2*right)/3.0;

    	if (ts(lmid) > ts(rmid)) left = lmid;

    	else right = rmid;

    }

    cout << setprecision(15) << fixed << sqrt(ts(left)) << '\n';

}

// Fastest known solution for this problem: