#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>

//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 1e9 + 7;
typedef long long ll;
typedef long long LL;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ll> pdl;
typedef pair<ld, ld> pdd;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
//typedef boost::multiprecision::cpp_int bigint;

typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);

//イコール
bool equal(Point a, Point b) {
	return (abs(a - b) < eps);
}

//内積
ld dot(Point a, Point b) {
	return real(conj(a) * b);
}

//外積
ld cross(Point a, Point b) {
	return imag(conj(a) * b);
}

//直線(2点保持)
struct Line {
	Point s, e;
};

//円(中心と半径)
struct Circle {
	Point p;
	ld r;
};

//三点の位置関係
//1 -> a,b,cが反時計回りの順に並ぶ
//-1 -> a,b,cが時計回りの順に並ぶ
//2 -> c,a,bの順に直線に並ぶ
//-2 -> a,b,cの順に直線に並ぶ
//0 -> a,c,bの順に直線に並ぶ
int threePointsPosition(Point a, Point b, Point c) {
	b -= a; c -= a;
	if (cross(b, c) > eps)return 1;
	if (cross(b, c) < -eps)return -1;
	if (dot(b, c) < 0)return 2;
	if (norm(b) < norm(c))return -2;
	return 0;
}

//二直線の交差判定(2直線のなす角!=0)
bool isis_ll(Line l, Line m) {
	return !equal(cross(l.e - l.s, m.e - m.s), 0);
}

//直線lと線分sの交差判定
//(線分の一端ともう一端が、直線を挟んで逆側にあればよい)
bool isis_ls(Line l, Line s) {
	return (cross(l.e - l.s, s.s - l.s) * cross(l.e - l.s, s.e - l.s) < eps);
}

//点が直線状に存在するかの判定
//(直線状2点にそれぞれ線を結び、なす角=0orπ)
bool isis_lp(Line l, Point p) {
	return(abs(cross(l.e - p, l.s - p)) < eps);
}

//点が線分上に存在するかの判定
//(線分の2点までの距離の和が線分の長さに等しければよい)
bool isis_sp(Line s, Point p) {
	return (abs(s.e - p) + abs(s.s - p) - abs(s.e - s.s) < eps);
}

//線分と線分の交差判定
bool isis_ss(Line s, Line t) {
	ll res1 = threePointsPosition(s.s, s.e, t.s) * threePointsPosition(s.s, s.e, t.e);
	ll res2 = threePointsPosition(t.s, t.e, s.s) * threePointsPosition(t.s, t.e, s.e);
	return (res1 <= 0 && res2 <= 0);
}

//点から直線に下ろす垂線の足
Point proj(Line l, Point p) {
	Point a = p - l.s, b = l.e - l.s;
	return l.s + (dot(a, b) / norm(b)) * b;
}

//直線と直線の交点
Point is_ll(Line s, Line t) {
	Point sv = s.e - s.s, tv = t.e - t.s;
	assert(cross(sv, tv) != 0);
	return s.s + sv * cross(tv, t.s - s.s) / cross(tv, sv);
}

ld dist_lp(Line l, Point p) {
	return abs(p - proj(l, p));
}

ld dist_ll(Line l, Line m) {
	return isis_ll(l, m) ? 0 : dist_lp(l, m.s);
}

ld dist_ls(Line l, Line s) {
	return isis_ls(l, s) ? 0 : min(dist_lp(l, s.s), dist_lp(l, s.e));
}

ld dist_sp(Line s, Point p) {
	Point r = proj(s, p);
	return isis_sp(s, r) ? abs(r - p) : min(abs(s.e - p), abs(s.s - p));
}

ld dist_ss(Line s, Line t) {
	if (isis_ss(s, t))return 0;
	return min({ dist_sp(s,t.s),dist_sp(s,t.e),dist_sp(t,s.s),dist_sp(t,s.e) });
}

istream& operator>>(istream& is, Point& p) {
	ld x, y;
	cin >> x >> y;
	p = Point(x, y);
	return is;
}

istream& operator>>(istream& is, Line& l) {
	Point a, b;
	cin >> a >> b;
	l = { a,b };
	return is;
}

ld degtorad(ll theta) {
	return theta * pi / 180;
}

ld radtodeg(ll theta) {
	return theta * 180 / pi;
}

//点Xを、点Cを中心に\theta rad回転
Point rotate(Point X, Point C, ld theta) {
	return (X - C) * Point(cosl(theta), sinl(theta)) + C;
}

//e^{i\theta }を返す
Point eitheta(ld theta) {
	return Point(cosl(theta), sinl(theta));
}

ld abs(Point p) {
	return sqrtl(p.real() * p.real() + p.imag() * p.imag());
}

//頂点が反時計回りに与えられている多角形
using Polygon = vector<Point>;

//三角形の面積
ld area(Point a, Point b, Point c) {
	return fabsl(cross(b - a, c - a)) / 2;
}

//多角形の面積
ld area(Polygon P) {
	ld ans = 0;
	for (ll n = 1; n < P.size() - 1; n++) {
		ll iscl = threePointsPosition(P[0], P[n], P[n + 1]);
		if (abs(iscl) != 1)continue;
		if (iscl == 1) {
			ans += area(P[0], P[n], P[n + 1]);
		}
		else {
			ans -= area(P[0], P[n], P[n + 1]);;
		}
	}
	return ans;
}

//多角形の凸性判定
bool isConvex(Polygon P) {
	for (ll n = 0; n < P.size(); n++) {
		if (threePointsPosition(P[n], P[(n + 1) % P.size()], P[(n + 2) % P.size()]) == -1) {
			return false;
		}
	}
	return true;
}

//多角形に対して点がどこにあるか
//0->内部 1->辺上 2->外部
ll isPointin(Polygon Poly, Point P) {
	bool in = false;
	for (ll i = 0; i < Poly.size(); i++) {
		Point a = Poly[i] - P;
		Point b = Poly[(i + 1) % Poly.size()] - P;
		if (a.imag() > b.imag())swap(a, b);
		if (a.imag() <= 0 && 0 < b.imag() && cross(a, b) < 0) in = !in;
		if (cross(a, b) == 0 && dot(a, b) <= 0) return 1;
	}
	return in ? 0 : 2;
}

LL N;
vector<Point> points;

ld makecircle(Point a, Point b, Point c) {
	Point ab = a + b;
	ab /= 2;
	Point va = a - ab;
	Line lab = {
		ab,{ab.real()-va.imag(),ab.imag()+va.real()}
	};
	Point bc = b + c;
	bc /= 2;
	Point vb = b - bc;
	Line lbc = {
		bc,{bc.real() - vb.imag(),bc.imag() + vb.real()}
	};
	if (!isis_ll(lab, lbc))return 1.0e15;
	Point cent = is_ll(lab, lbc);
	ld rr = (cent.real() - a.real()) * (cent.real() - a.real()) + (cent.imag() - a.imag()) * (cent.imag() - a.imag());
	for (LL n = 0; n < N; n++) {
		ld dx = cent.real() - points[n].real();
		ld dy = cent.imag() - points[n].imag();
		if (dx * dx + dy * dy > rr + eps)return 1.0e15;
	}
	return rr;
}

ld makecircle(Point a, Point b) {
	Point m = a + b;
	m /= 2;
	ld rr = abs(m - a);
	for (LL n = 0; n < N; n++) {
		if (abs(points[n] - m) > rr + eps)return 1.0e15;
	}
	return rr * rr;
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	cin >> N;
	points.resize(N);
	for (LL n = 0; n < N; n++) {
		ld r, i;
		cin >> r >> i;
		points[n] = { r,i };
	}
	if (N == 2) {
		Point m = (points[0] + points[1]);
		m /= 2;
		m = points[0] - m;
		cout << setprecision(12) << abs(m) << "\n";
		return 0;
	}
	ld ans = 1.0e15;
	for (LL s1 = 0; s1 < N; s1++) {
		for (LL s2 = s1 + 1; s2 < N; s2++) {
			for (LL s3 = s2 + 1; s3 < N; s3++) {
				ans = min(ans, makecircle(points[s1], points[s2], points[s3]));
			}
		}
	}
	for (LL s1 = 0; s1 < N; s1++) {
		for (LL s2 = s1 + 1; s2 < N; s2++) {
			ans = min(ans, makecircle(points[s1], points[s2]));
		}
	}
	cout << setprecision(12) << sqrt(ans) << "\n";
	return 0;
}

Measured memory_bytes: 512