#include <bits/stdc++.h>

using namespace std;

typedef double cod;
double eps = 1e-7;
bool eq(cod a, cod b){ return abs(a - b) <= eps; }

struct vec{
	cod x, y; int id;
	vec(cod a = 0, cod b = 0) : x(a), y(b) {}
	vec operator+(const vec &o) const{
		return {x + o.x, y + o.y};
	}
	vec operator-(const vec &o) const{
		return {x - o.x, y - o.y};
	}
	vec operator*(cod t) const{
		return {x * t, y * t};
	}
	vec operator/(cod t) const{
		return {x / t, y / t};
	}
	cod operator*(const vec &o) const{ // cos
		return x * o.x + y * o.y;
	}
	cod operator^(const vec &o) const{ // sin
		return x * o.y - y * o.x;
	}
	bool operator==(const vec &o) const{
		return eq(x, o.x) && eq(y, o.y);
	}
	bool operator<(const vec &o) const{
		if(!eq(x, o.x)) return x < o.x;
		return y < o.y;
	}
	cod cross(const vec &a, const vec &b) const{
		return (a-(*this)) ^ (b-(*this));
	}
    int ccw(const vec &a, const vec &b) const{
        cod tmp = cross(a, b);
        return (tmp > eps) - (tmp < -eps);
    }
	cod dot(const vec &a, const vec &b) const{
		return (a-(*this)) * (b-(*this));
	}
	cod len() const{
		return sqrt(x * x + y * y); // <
	}
	double angle(const vec &a, const vec &b) const{
		return atan2(cross(a, b), dot(a, b));
	}
	double tan(const vec &a, const vec &b) const{
		return cross(a, b) / dot(a, b);
	}
	vec unit() const{
		return operator/(len());
	}
	int quad() const{
		if(x > 0 && y >=0) return 0;
		if(x <=0 && y > 0) return 1;
		if(x < 0 && y <=0) return 2;
		return 3;
	}
	bool comp(const vec &a, const vec &b) const{
		return (a - *this).comp(b - *this);
	}
	bool comp(vec b){
		if(quad() != b.quad()) return quad() < b.quad();
		if(!eq(operator^(b), 0)) return operator^(b) > 0;
		return (*this) * (*this) < b * b;
	}
	template<class T>
	void sort_by_angle(T first, T last) const{
		std::sort(first, last, [=](const vec &a, const vec &b){
			return comp(a, b);
		});
	}
	vec rot90() const{ return {-y, x}; }
	vec rot(double a) const{
		return {cos(a)*x -sin(a)*y, sin(a)*x +cos(a)*y};
	}
    vec proj(const vec &b) const{ // proj of *this onto b
        cod k = operator*(b) / (b * b);
        return b * k;
    }
    // proj of (*this) onto the plane orthogonal to b
    vec rejection(vec b) const{
        return (*this) - proj(b);
    }
};

struct line{
	cod a, b, c; vec n;
	line(vec q, vec w){ // q.cross(w, (x, y)) = 0
		a = -(w.y-q.y);
		b = w.x-q.x;
		c = -(a * q.x + b * q.y);
		n = {a, b};
	}
	line(cod aa, cod bb, cod cc) {
		a = aa, b = bb, c = cc;
		n = {a, b};
	}
	cod dist(const vec &o) const{
		return abs(eval(o)) / n.len();
	}
	bool contains(const vec &o) const{
		return eq(a * o.x + b * o.y + c, 0);
	}
	cod dist(const line &o) const{
		if(!parallel(o)) return 0;
		if(!eq(o.a * b, o.b * a)) return 0;
		if(!eq(a, 0))
			return abs(c - o.c * a / o.a) / n.len();
		if(!eq(b, 0))
			return abs(c - o.c * b / o.b) / n.len();
		return abs(c - o.c);
	}
	bool parallel(const line &o) const{
		return eq(n ^ o.n, 0);
	}
	bool operator==(const line &o) const{
		if(!eq(a*o.b, b*o.a)) return false;
		if(!eq(a*o.c, c*o.a)) return false;
		if(!eq(c*o.b, b*o.c)) return false;
		return true;
	}
	bool intersect(const line &o) const{
		return !parallel(o) || *this == o;
	}
	vec inter(const line &o) const{
		if(parallel(o)){
			if(*this == o){ }
			else{ /* dont intersect */ }
		}

		auto tmp = n ^ o.n;
		return {(o.c*b -c*o.b)/tmp, (o.a*c -a*o.c)/tmp};
	}
	vec at_x(cod x) const{
		return {x, (-c-a*x)/b};
	}
	vec at_y(cod y) const{
		return {(-c-b*y)/a, y};
	}
	cod eval(const vec &o) const{
		return a * o.x + b * o.y + c;
	}
};

line mediatrix(const vec &a, const vec &b) {
	auto tmp = (b - a) * 2;
	return line(tmp.x, tmp.y, a * a - b * b);
}
struct circle {
	vec c; cod r;
	circle() : c(0, 0), r(0) {}
	circle(const vec o) : c(o), r(0) {}
	circle(const vec &a, const vec &b) {
		c = (a + b) * 0.5; r = (a - c).len();
	}
	circle(const vec &a, const vec &b, const vec &cc) {
		c = mediatrix(a, b).inter(mediatrix(b, cc));
		r = (a - c).len();
	}
	bool inside(const vec &a) const {
		return (a - c).len() <= r;
	}
};
circle min_circle_cover(vector<vec> v) {
	random_shuffle(v.begin(), v.end());
	circle ans;
	int n = (int)v.size();
	for(int i = 0; i < n; i++) if(!ans.inside(v[i])) {
		ans = circle(v[i]);
		for(int j = 0; j < i; j++) if(!ans.inside(v[j])){
			ans = circle(v[i], v[j]);
			for(int k=0; k<j; k++)if(!ans.inside(v[k])){
				ans = circle(v[i], v[j], v[k]);
			}
		}
	}
	return ans;
}

int main() {
	int n;
	cin >> n;
	vector<vec> v(n);
	for(auto &p : v) cin >> p.x >> p.y;
	cout << fixed << setprecision(20) << min_circle_cover(v).r << endl;
}


Measured memory_bytes: 256