#include <bits/stdc++.h>

using namespace std;

constexpr double PI = 3.14159265358979323846;
constexpr double eps = 1e-11;
constexpr double INF = 1e20;
constexpr int N = 50;

template <class T>
struct Point {
	T x, y;

	/* O(1) - Negative vector. */
	Point<T> operator - () const {
		return {-this->x, -this->y};
	}
	
	/* O(1) - Vector sum. */
	Point<T> operator + (const Point<T> &b) const {
		return {this->x + b.x, this->y + b.y};
	}

	/* O(1) - Vector subtraction. */
	Point<T> operator - (const Point<T> &b) const {
		return {this->x - b.x, this->y - b.y};
	}

	/* O(1) - Dot product. */
	T operator * (const Point<T> &b) const {
		return (this->x * b.x) + (this->y * b.y);
	}

	/* O(1) - Cross product. */
	T operator ^ (const Point<T> &b) const {
		return (this->x * b.y) - (this->y * b.x);
	}

	/* O(1) - Squared norm. */
	T operator ! () const {
		return (this->x * this->x) + (this->y * this->y);
	}

	/* O(1) - Lesser than. */
	bool operator < (const Point<T> &b) const {
		if (this->x == b.x) {
			return this->y < b.y;
		}

		return this->x < b.x;
	}

	/* O(1) - Greater than. */
	bool operator > (const Point<T> &b) const {
		return b < *this;
	}

	/* O(1) - Equal. */
	bool operator == (const Point<T> &b) const {
		return !(*this < b) and !(*this > b);
	}

	/* O(1) - Different. */
	bool operator != (const Point<T> &b) const {
		return !(*this == b);
	}
};

/* O(1) - String conversion. */
template <class T>
string to_string(const Point<T> &p) {
	return "(" + to_string(p.x) + ", " + to_string(p.y) + ")";
}

double dist(const Point<double> &a, const Point<double> &b) {
	return sqrt(!(b - a));
}

/* O(1) - Rotates vector p by theta radians. */
template <class T>
Point<T> rotate(const Point<T> &p, double theta) {
	return {p.x * cos(theta) - p.y * sin(theta), p.x * sin(theta) + p.y * cos(theta)};
}

/* O(1) - Rotates points p around pivot by theta radians. */
template <class T>
Point<T> rotate(const Point<T> &pivot, const Point<T> &p, double theta) {
	return pivot + rotate(p - pivot, theta);
}

/* O(1) - Returns the point of intersection between a line defined by AB and a line defined by CD.
   You need to first guarantee that the lines have exactly 1 intersection point.
   Caution with overflowing the Fractions because the numerator and the denominator of the intersection point will be of the order of x^4 and y^4. */
Point<double> line_line_intersection(const Point<double> &a, const Point<double> &b, const Point<double> &c, const Point<double> &d) {
	if (a == b and c == d) { // Both are degenerate.
		return a;
	}
	
	if (a == b) { // AB is degenerate.
		return a;
	}
	
	if (c == d) { // CD is degenerate.
		return c;
	}

	Point<double> ax1 = {a.x, 1.0};
	Point<double> ay1 = {a.y, 1.0};

	Point<double> bx1 = {b.x, 1.0};
	Point<double> by1 = {b.y, 1.0};

	Point<double> cx1 = {c.x, 1.0};
	Point<double> cy1 = {c.y, 1.0};

	Point<double> dx1 = {d.x, 1.0};
	Point<double> dy1 = {d.y, 1.0};

	Point<double> px_num_a = {a ^ b, ax1 ^ bx1};
	Point<double> px_num_b = {c ^ d, cx1 ^ dx1};

	Point<double> py_num_a = {a ^ b, ay1 ^ by1};
	Point<double> py_num_b = {c ^ d, cy1 ^ dy1};

	Point<double> den_a = {ax1 ^ bx1, ay1 ^ by1};
	Point<double> den_b = {cx1 ^ dx1, cy1 ^ dy1};

	return {(px_num_a ^ px_num_b) / (den_a ^ den_b), (py_num_a ^ py_num_b) / (den_a ^ den_b)};
}

Point<double> p[N + 1];
int n;

double solve(const Point<double> &q) {
	double ans = 0.0;

	for (int i = 1; i <= n; i++) {
		ans = max(ans, dist(q, p[i]));
	}

	return ans;
}

bool collinear(const Point<double> &a, const Point<double> &b, const Point<double> &c) {
	return abs((b - a) ^ (c - a)) < eps;
}

int main() {
	int i, j, k;
	double ans;

	scanf("%d", &n);

	for (i = 1; i <= n; i++) {
		scanf("%lf%lf", &p[i].x, &p[i].y);
	}

	if (n == 2) {
		printf("%.9lf\n", dist(p[1], p[2]) / 2.0);
		return 0;
	}

	ans = INF;

	for (i = 1; i <= n; i++) {
		for (j = i + 1; j <= n; j++) {
			ans = min(ans, solve({(p[i].x + p[j].x) / 2.0, (p[i].y + p[j].y) / 2.0}));
		}
	}

	for (i = 1; i <= n; i++) {
		for (j = i + 1; j <= n; j++) {
			for (k = j + 1; k <= n; k++) {
				if (collinear(p[i], p[j], p[k])) {
					continue;
				}

				Point<double> ab = {(p[i].x + p[j].x) / 2.0, (p[i].y + p[j].y) / 2.0};
				Point<double> bc = {(p[j].x + p[k].x) / 2.0, (p[j].y + p[k].y) / 2.0};

				Point<double> ab_d = rotate(p[j] - p[i], PI / 2.0);
				Point<double> bc_d = rotate(p[k] - p[j], PI / 2.0);

				Point<double> q = line_line_intersection(ab, ab + ab_d, bc, bc + bc_d);
				ans = min(ans, solve(q));
			}
		}
	}

	printf("%.9lf\n", ans);

	return 0;
}

Measured memory_bytes: 512