#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <string>
#include <sstream>
#include <algorithm>
#include <random>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <cassert>
#include <climits>
#include <bitset>
#include <functional>
#include <iomanip>

#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)

using namespace std;

struct P {
	int x;
	int y;
};

double distance2(P& v)
{
	return v.x * v.x + v.y * v.y;
}

void calc_circle(P& p1, P& p2, P& p3, double& cx, double& cy, double& r)
{
	double x1 = distance2(p1);
	double x2 = distance2(p2);
	double x3 = distance2(p3);

	double dd12 = x1 - x2;
	double dd23 = x2 - x3;

	double dx12 = p1.x - p2.x;
	double dx23 = p2.x - p3.x;
	double dy12 = p1.y - p2.y;
	double dy23 = p2.y - p3.y;

	double vdiv = 2 * (dx12 * dy23 - dy12 * dx23);

	cx = (dy23 * dd12 - dy12 * dd23) / vdiv;
	cy = (dx12 * dd23 - dx23 * dd12) / vdiv;

	r = hypot(p1.x - cx, p1.y - cy);
}

void calc_circle_on_line(P& p1, P& p2, P& p3, double& cx, double& cy, double& r)
{
	int xmax = INT_MIN, ymax = INT_MIN;
	int xmin = INT_MAX, ymin = INT_MAX;

	xmax = max(p1.x, xmax);
	xmax = max(p2.x, xmax);
	xmax = max(p3.x, xmax);
	xmin = min(p1.x, xmin);
	xmin = min(p2.x, xmin);
	xmin = min(p3.x, xmin);

	ymax = max(p1.y, ymax);
	ymax = max(p2.y, ymax);
	ymax = max(p3.y, ymax);
	ymin = min(p1.y, ymin);
	ymin = min(p2.y, ymin);
	ymin = min(p3.y, ymin);

	cx = ((double)(xmax + xmin)) / 2.0;
	cy = ((double)(ymax + ymin)) / 2.0;

	r = hypot(xmax - xmin, ymax - ymin) / 2.0;
}

bool on_line(P& p1, P& p2, P& p3)
{
	int dx1 = p2.x - p1.x;
	int dx2 = p3.x - p2.x;
	int dy1 = p2.y - p1.y;
	int dy2 = p3.y - p2.y;

	return (dy1 * dx2 == dx1 * dy2);
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout << fixed << setprecision(20);

	int n; cin >> n;
	vector<P> ps(n);
	for (auto& p : ps) {
		cin >> p.x >> p.y;
	}

	double ans = numeric_limits<double>::max();
	FOR_LT(i, 0, n) {
		FOR_LT(j, i + 1, n) {
			FOR_LT(k, j + 1, n) {
				P p1 = ps[i];
				P p2 = ps[j];
				P p3 = ps[k];

				double cx = 0.0, cy = 0.0;
				double r = 0.0;
				if (on_line(p1, p2, p3)) {
					continue;
				}
				else {
					calc_circle(p1, p2, p3, cx, cy, r);
				}

				double e = r * 0.00000001;
				bool is_ok = true;
				FOR_LT(l, 0, n) {
					double d = hypot(cx - ps[l].x, cy - ps[l].y);
					if (d - e > r) {
						is_ok = false;
						break;
					}
				}
				if (is_ok) {
					ans = min(ans, r);
				}
			}
		}
	}
	FOR_LT(i, 0, n) {
		FOR_LT(j, i + 1, n) {
			P p1 = ps[i];
			P p2 = ps[j];

			double cx = ((double)(p1.x + p2.x)) / 2.0;
			double cy = ((double)(p1.y + p2.y)) / 2.0;
			double r = hypot(p1.x - p2.x, p1.y - p2.y) / 2.0;

			double e = r * 0.00000001;
			bool is_ok = true;
			FOR_LT(l, 0, n) {
				double d = hypot(cx - ps[l].x, cy - ps[l].y);
				if (d - e > r) {
					is_ok = false;
					break;
				}
			}
			if (is_ok) {
				ans = min(ans, r);
			}
		}
	}

	cout << ans << endl;

	return 0;
}

Measured memory_bytes: 256