#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <cmath>

using namespace std;
#define PI 3.1415926535897932384626433832795
#define MOD (1000000007)
#define EPS (1e-10)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, s, n) for (int i = (s); i <= (n); i++)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; i--)
#define rrepc(i, s, n) for (int i = (s); i >= (n); i--)
typedef long long ll;
typedef unsigned long long ull;

/*================================================
	Geometry
================================================*/
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;

class Point {
public:
	double x, y;

	Point(double x = 0, double y = 0) : x(x), y(y) {}

	Point operator + (Point p) { return Point(x + p.x, y + p.y); }
	Point operator - (Point p) { return Point(x - p.x, y - p.y); }
	Point operator * (double a) { return Point(a * x, a * y); }
	Point operator / (double a) { return Point(x / a, y / a); }

	double abs() { return sqrt(norm()); }
	double norm() { return x * x + y * y; }

	bool operator < (const Point& p) const {
		return x != p.x ? x < p.x : y < p.y;
	}

	bool operator == (const Point& p) const {
		return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
	}
};
typedef Point Vector;
struct Segment { Point p1, p2; };
typedef Segment Line;
class Circle {
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
};
typedef vector<Point> Polygon;

double dot(Vector a, Vector b) { return a.x * b.x + a.y * b.y; }
double cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }

int ccw(Point p0, Point p1, Point p2) {
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
	if (cross(a, b) < -EPS) return CLOCKWISE;
	if (dot(a, b) < -EPS) return ONLINE_BACK;
	if (a.norm() < b.norm()) return ONLINE_FRONT;
	return ON_SEGMENT;
}

double Distance_PP(Point a, Point b) { return (a - b).abs(); }

Point circumcenter(Point& p1, Point& p2, Point& p3)
{
	Point ret;
	double xn, xd, yn, yd, x, y;
	double a = p1.x, b = p1.y, c = p2.x, d = p2.y, e = p3.x, f = p3.y;
	double a2 = a * a, b2 = b * b, c2 = c * c, d2 = d * d, e2 = e * e, f2 = f * f;

	yn = (e - a) * (a2 + b2 - c2 - d2) - (c - a) * (a2 + b2 - e2 - f2);
	yd = 2 * (e - a) * (b - d) - 2 * (c - a) * (b - f);
	y = yn / yd;

	if (abs(p2.x - p1.x) < EPS) {
		xn = 2 * (b - f) * y - a2 - b2 + e2 + f2;
		xd = 2 * (e - a);
	}
	else {
		xn = 2 * (b - d) * y - a2 - b2 + c2 + d2;
		xd = 2 * (c - a);
	}
	x = xn / xd;

	ret.x = x;
	ret.y = y;

	return ret;
}

int N;
Point p[50];

double farest(Point& pt)
{
	double ret = 0;

	rep(i, N) ret = max(ret, Distance_PP(pt, p[i]));

	return ret;
}

int main()
{
	Point cand;
	double ans = 10000000;

	cin >> N;
	rep(i, N) cin >> p[i].x >> p[i].y;

	repc(i, 0, N - 2) repc(j, i + 1, N - 1) {
		cand.x = (p[i].x + p[j].x) / 2;
		cand.y = (p[i].y + p[j].y) / 2;
		ans = min(ans, farest(cand));
	}

	repc(i, 0, N - 3) repc(j, i + 1, N - 2) repc(k, j + 1, N - 1) {
		int ccwt = ccw(p[i], p[j], p[k]);
		if (ccwt != COUNTER_CLOCKWISE && ccwt != CLOCKWISE) continue;
		cand = circumcenter(p[i], p[j], p[k]);
		ans = min(ans, farest(cand));
	}

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

	return 0;
}


Measured memory_bytes: 256