/*▄███████▀▀▀▀▀▀███████▄
░▐████▀▒ЗАПУСКАЕМ▒▀██████▄
░███▀▒▒▒▒▒ДЯДЮ▒▒▒▒▒▒▀█████
░▐██▒▒▒▒▒БОГДАНА▒▒▒▒▒████▌
░▐█▌▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒████▌
░░█▒▄▀▀▀▀▀▄▒▒▄▀▀▀▀▀▄▒▐███▌
░░░▐░░░▄▄░░▌▐░░░▄▄░░▌▐███▌
░▄▀▌░░░▀▀░░▌▐░░░▀▀░░▌▒▀▒█▌
░▌▒▀▄░░░░▄▀▒▒▀▄░░░▄▀▒▒▄▀▒▌
░▀▄▐▒▀▀▀▀▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒█
░░░▀▌▒▄██▄▄▄▄████▄▒▒▒▒█▀
░░░░▄█████████████  █▒▒▐▌
░░░▀███▀▀████▀█████▀▒▌
░░░░░▌▒▒▒▄▒▒▒▄▒▒▒▒▒▒▐
░░░░░▌▒▒▒▒▀▀▀▒▒▒▒▒▒▒▐*/
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("fast-math")
#include <iostream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <math.h>
#include <set>
#include <stack>
#include <bitset>
#include <map>
#include <queue>
#include <random>
#include <unordered_set>
#include <unordered_map>
#define DEBUG
#define fi first
#define se second
#define pqueue priority_queue
#define pb(x) push_back(x)
// #define endl '\n'
#define all(x) x.begin(), x.end()
//#define int long long
#define mk(a, b) make_pair(a, b)
     
using namespace std;
      
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vector<ll> > vvi;
typedef vector<ull> vull;
typedef vector<ll> vll;
// typedef tuple<ll, ll, ll> tiii;
typedef pair<int, int> pii;
typedef vector<pair<int, int> > vpii;
typedef pair<ll, ll> pll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector< vector<ll> > vvi;
typedef vector<char> vc;
      
const ll INF = 1e9 + 228;
const ll INFLL = 1e18;
const ll MOD = 1e9 + 7;
// const ll MAXN = 3e5;
const ld eps = 1e-7;
const ld eps2 = 1e-9;
const ll MOD2 = 998244353;
const ll dosz = 5e5;
const ll SZ = (1<<18);
const ld PI = atan2l(0, -1);
     
void fast_io(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    #ifdef DEBUG
//      freopen("a.in", "w", stdout);
    #endif
}

bool more_then(ld a, ld b){
	return ((a-b) > eps); 
}

bool less_then(ld a, ld b){
	return ((b-a)>eps);
}

struct circle{
	ld x, y;
	ld r;
	circle(ld _x, ld _y, ld _r){
		x = _x, y = _y, r = _r;
	}
	bool isPoint(ld x1, ld y1){
		x1 -= x;
		y1 -= y;
		ld dist = sqrtl(x1*x1 + y1*y1);
		return less_then(dist, r);
	}
	circle(ld x1, ld y1, ld x2, ld y2){
		x = (x1+x2)/2.0;
		y = (y1+y2)/2.0;
		r = sqrtl((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2))/2.0;
	}
};

struct line{
	ld a, b, c;
	line(){};
	line(ld x1, ld y1, ld x2, ld y2){
		a = y1-y2;
		b = x2-x1;
		c = -a*x1 -b*y1;
	}
	pair<ld, ld> get_same(line b){
		ld x = - ((this->c)*b.b - b.c*(this->b)) / ((this->a) * b.b - b.a * (this->b));
	       	ld y = - ((this->a) * b.c - b.a*(this->c)) / ((this->a)*b.b - b.a * (this->b));
		return make_pair(x, y);	
	}
};

vector<pair<ld, ld> > kek;

circle DiskFor3Points(pair<ld, ld> point1, pair<ld, ld> point2, pair<ld, ld> point3){
	pair<ld, ld> fir = make_pair((point1.first + point2.first)/2.0, (point1.second+point2.second)/2.0);
	pair<ld, ld> vec = make_pair(point1.first - point2.first, point1.second-point2.second);
	pair<ld, ld> new_vec = make_pair(vec.second, -vec.first);
	pair<ld, ld> sec = make_pair((point2.first + point3.first)/2.0, (point2.second+point3.second)/2.0);
	pair<ld, ld> vec2 = make_pair(point2.first - point3.first, point2.second-point3.second);
	pair<ld, ld> new_vec2 = make_pair(vec2.second, -vec2.first);
	line a, b;
	a = line(fir.first, fir.second, fir.first + new_vec.first, fir.second+new_vec.second);
	b = line(sec.first, sec.second, sec.first + new_vec2.first, sec.second+new_vec2.second);
	pair<ld, ld> kek = a.get_same(b);
	circle lol = circle(kek.first, kek.second, sqrtl((point1.first - kek.first) * (point1.first - kek.first) + (point1.second - kek.second) * (point1.second - kek.second)));
	return lol;

}

circle minDiskWith2Points(vector<pair<ld, ld> > points, pair<ld, ld> point1, pair<ld, ld> point2){
	circle cur = circle(point1.first, point1.second, point2.first, point2.second);
	int n = points.size();
	for(int i=0; i<n; i++){
		if(!cur.isPoint(points[i].first, points[i].second)){
			cur = DiskFor3Points(point1, point2, points[i]);
		}
	}
	return cur;
}

circle minDiskWithPoint(vector<pair<ld, ld> > points, pair<ld, ld> point){
	random_shuffle(all(points));
	circle cur = circle(points[0].first, points[0].second, point.first, point.second);
	int n = points.size();
	vector<pair<ld, ld> > points2; 
	points2.pb(points[0]);
	for(int i=1; i<n; i++){
		if(!cur.isPoint(points[i].first, points[i].second)){
			cur = minDiskWith2Points(points2, points[i], point);
		}
		points2.pb(points[i]);
	}
	return cur;
}

circle minDisk(){
	vector<pair<ld, ld> > lol;
	lol = kek;
	random_shuffle(all(lol));
	circle cur = circle(lol[0].first, lol[0].second, lol[1].first, lol[1].second);
	int n = lol.size();
	vector<pair<ld, ld> > points;
	points.pb(lol[0]);
	points.pb(lol[1]);
	for(int i=2; i<n; i++){
		if(!cur.isPoint(lol[i].first, lol[i].second)){	
			cur = minDiskWithPoint(points, lol[i]);
		} 
		points.pb(lol[i]);
	}
	return cur;
}

void solve(){
	int n;
	cin >> n;
	for(int i=0; i<n; i++){
		ld x, y, r;
		cin >> x >> y;
		kek.pb(make_pair(x, y));
	}

	circle lolkek = minDisk();
	cout << lolkek.r << endl;
}

signed main(){
        fast_io();
	srand(time(NULL));
	cout << fixed << setprecision(12);
	int q = 1;
//	cin >> q;
	while(q--)
		solve();
     
}






Measured memory_bytes: 384