// Original C++ solution (slower):
#define _CRT_SECURE_NO_WARNINGS



#include <iostream>

#include <string>

#include <algorithm>

#include <vector>

#include <cmath>

#include <queue>

#include <map>

#include <unordered_map>

#include <set>

#include <functional>

#include <bitset>

#include <numeric>

#include <complex>

#include <cassert>

#include <random>

using namespace std;

using ll = long long;







// Geometry

using Float = long double;

using Point = complex<Float>;

constexpr Float EPS = 1e-7;



inline int sgn(const Float &r) {

	return (r > EPS) - (r < -EPS);

}

bool operator==(const Point &a, const Point &b) {

	bool xeq = sgn(real(a) - real(b)) == 0;

	bool yeq = sgn(imag(a) - imag(b)) == 0;

	return xeq && yeq;

}

bool operator<(const Point &a, const Point &b) {

	int xsgn = sgn(real(a) - real(b));

	if (xsgn == 0) {

		return sgn(imag(a) - imag(b)) < 0;

	}

	return xsgn < 0;

}



Float dot(const Point &a, const Point &b) {

	return real(conj(a)*b);

}

Float cross(const Point &a, const Point &b) {

	return imag(conj(a)*b);

}



struct Circle {

	Point center;

	Float radius;



	Circle() {}

	Circle(const Point &center, const Float &radius)

		: center(center), radius(radius) {}



	// 1: interior, 0: boundary, -1: exterior

	int relation(const Point &p) const {

		return sgn(radius - abs(p - center));

	}

};



vector<Point> intersection(const Circle &a, const Circle &b) {

	Point p = b.center - a.center;

	Float d = norm(p);

	Float t = (d + a.radius*a.radius - b.radius*b.radius) / 2.;

	Float q = d*a.radius*a.radius - t*t;

	int qsgn = sgn(q);

	vector<Point> ret;

	if (qsgn < 0) return ret;

	ret.emplace_back(

		(t*real(p) + imag(p)*sqrt(q)) / d,

		(t*imag(p) - real(p)*sqrt(q)) / d

	);

	if (qsgn > 0) {

		ret.emplace_back(

			(t*real(p) - imag(p)*sqrt(q)) / d,

			(t*imag(p) + real(p)*sqrt(q)) / d

		);

	}

	for (auto &x : ret) {

		x += a.center;

	}

	return ret;

}





int main() {

	int n; cin >> n;

	vector<Point> p(n);

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

		Float x, y; cin >> x >> y;

		p[i] = { x, y };

	}

	vector<Circle> c(n);

	for (int i = 0; i < n; i++) c[i].center = p[i];

	auto ok = [&](const Point &center) {

		bool ret = true;

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

			ret &= c[i].relation(center) >= 0;

		}

		return ret;

	};

	Float lo = 0, hi = 1e9;

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

		Float mid = (hi + lo)/2;

		for (int i = 0; i < n; i++) c[i].radius = mid;

		bool flag = false;

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

			for (int j = i + 1; j < n; j++) {

				auto points = intersection(c[i], c[j]);

				cerr << points.size() << endl;

				for (const auto &v : points) {

					flag |= ok(v);

				}

			}

		}

		if (flag) hi = mid;

		else lo = mid;

	}

	printf("%.15Lf\n", hi);

	return 0;

}


// Optimized solution to the same problem (faster):
#define _CRT_SECURE_NO_WARNINGS



#include <iostream>

#include <string>

#include <algorithm>

#include <vector>

#include <cmath>

#include <queue>

#include <map>

#include <unordered_map>

#include <set>

#include <functional>

#include <bitset>

#include <numeric>

#include <complex>

#include <cassert>

#include <random>

using namespace std;

using ll = long long;







// Geometry

using Float = double;

using Point = complex<Float>;

constexpr Float EPS = 1e-7;



inline int sgn(const Float &r) {

	return (r > EPS) - (r < -EPS);

}

bool operator==(const Point &a, const Point &b) {

	bool xeq = sgn(real(a) - real(b)) == 0;

	bool yeq = sgn(imag(a) - imag(b)) == 0;

	return xeq && yeq;

}

bool operator<(const Point &a, const Point &b) {

	int xsgn = sgn(real(a) - real(b));

	if (xsgn == 0) {

		return sgn(imag(a) - imag(b)) < 0;

	}

	return xsgn < 0;

}



Float dot(const Point &a, const Point &b) {

	return real(conj(a)*b);

}

Float cross(const Point &a, const Point &b) {

	return imag(conj(a)*b);

}



struct Circle {

	Point center;

	Float radius;



	Circle() {}

	Circle(const Point &center, const Float &radius)

		: center(center), radius(radius) {}



	// 1: interior, 0: boundary, -1: exterior

	int relation(const Point &p) const {

		return sgn(radius - abs(p - center));

	}

};



vector<Point> intersection(const Circle &a, const Circle &b) {

	Point p = b.center - a.center;

	Float d = norm(p);

	Float t = (d + a.radius*a.radius - b.radius*b.radius) / 2.;

	Float q = d*a.radius*a.radius - t*t;

	int qsgn = sgn(q);

	vector<Point> ret;

	if (qsgn < 0) return ret;

	ret.emplace_back(

		(t*real(p) + imag(p)*sqrt(q)) / d,

		(t*imag(p) - real(p)*sqrt(q)) / d

	);

	if (qsgn > 0) {

		ret.emplace_back(

			(t*real(p) - imag(p)*sqrt(q)) / d,

			(t*imag(p) + real(p)*sqrt(q)) / d

		);

	}

	for (auto &x : ret) {

		x += a.center;

	}

	return ret;

}





int main() {

	int n; cin >> n;

	vector<Point> p(n);

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

		Float x, y; cin >> x >> y;

		p[i] = { x, y };

	}

	vector<Circle> c(n);

	for (int i = 0; i < n; i++) c[i].center = p[i];

	auto ok = [&](const Point &center) {

		bool ret = true;

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

			ret &= c[i].relation(center) >= 0;

		}

		return ret;

	};

	Float lo = 0, hi = 1e9;

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

		Float mid = (hi + lo)/2;

		for (int i = 0; i < n; i++) c[i].radius = mid;

		bool flag = false;

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

			for (int j = i + 1; j < n; j++) {

				auto points = intersection(c[i], c[j]);

				cerr << points.size() << endl;

				for (const auto &v : points) {

					flag |= ok(v);

				}

			}

		}

		if (flag) hi = mid;

		else lo = mid;

	}

	printf("%.15f\n", hi);

	return 0;

}


// Fastest known solution for this problem: