#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <numeric>
#include <list>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#include <deque>

using namespace std;

/*
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
*/

typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<long long, long long> pll;
typedef vector<pll> vpll;

typedef long double ld;
typedef vector<ld> vld;

typedef vector<bool> vb;

#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, n) for (ll i = 1; i <= (n); i++)
#define rrep(i, n) for (ll i = (n) - 1; i >= 0; i--)
#define rreps(i, n) for (ll i = (n); i >= 1; i--)
#define all(v) (v).begin(), (v).end()

template <class T> void chmin(T& a, T b) { a = min(a, b);}
template <class T> void chmax(T& a, T b) { a = max(a, b);}

constexpr int INF = 1 << 30;
constexpr ll INFL = 1LL << 60;
constexpr ll MOD = 1000000007;
constexpr ld EPS = 1e-12;
//constexpr ld PI = 3.14159265358979323846;
ld PI = acos(-1.0);

struct Point {
	ld x;
	ld y;
	Point(ld x = 0, ld y = 0) : x(x), y(y) {}

	Point& operator+=(const Point& a) { x += a.x; y += a.y; return *this; }
	Point& operator-=(const Point& a) { x -= a.x; y -= a.y; return *this; }
	Point operator+(const Point& a) const { Point ret(*this); return ret += a; }
	Point operator-(const Point& a) const { Point ret(*this); return ret -= a; }
    Point operator*(ld a) { x *= a; y *= a; return *this; }
	bool operator==(const Point& a) const { return x == a.x && y == a.y; }
	bool operator!=(const Point& a) const { return x != a.x || y == a.y; }
	bool operator<(const Point& a) const { return x < a.x || (x == a.x && y < a.y); }
	bool operator>(const Point& a) const { return x > a.x || (x == a.x && y > a.y); }
    
    Point rotate(ld th) {
        ld x_ = x * cos(th) - y * sin(th);
        ld y_ = x * sin(th) + y * cos(th);
        return Point(x_, y_);
    }

    ld size() { return sqrt(x*x + y*y); }
    Point norm() { return Point(x/size(), y/size()); }
};

ld dist(const Point& a, const Point& b) {
    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}

Point middle(const Point& a, const Point& b) {
    return Point((a.x+b.x)/2.0, (a.y+b.y)/2.0);
}

void solve() {
    ll n;
    cin >> n;
    vector<Point> p(n);
    for(ll i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
    ld ok = 1000.0, ng = 0.0;
    ld r;
    while(ok - ng > EPS) {
        r = (ok + ng) / 2.0;
        vector<Point> cross;
        for(ll i = 0; i < n - 1; i++) {
            for(ll j = i + 1; j < n; j++) {
                ld d = dist(p[i], p[j]);
                if(d > 2 * r + EPS) continue;
                Point mid = middle(p[i], p[j]);
                Point dif = p[i] - p[j];
                ld h = sqrt(r*r - (d/2.0)*(d/2.0));
                cross.push_back(mid + dif.norm().rotate(PI/2.0) * h);
                cross.push_back(mid + dif.norm().rotate(-PI/2.0) * h);
            }
        }
        bool check = false;
        for(auto cp : cross) {
            bool tmp_check = true;
            for(ll i = 0; i < n; i++) {
                if(dist(cp, p[i]) > r + EPS) tmp_check = false;
            }
            if(tmp_check) {
                check = true;
                break;
            }
        }
        if(check) ok = r;
        else ng = r;
    }
    cout << r << endl;
    return;
}

int main() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    solve();
}

Measured memory_bytes: 548