#include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <bitset>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;

using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)
#define REP(i, n) rep(i, 0, n)
#define ALL(v) v.begin(),v.end()
template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }
template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }
#define DEBUG_VLL(vec) REP(sz, vec.size()) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');

const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;

#define EPS (1e-12)
struct Point {
    double x, y;
    Point(double x = 0.0, double y = 0.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 Circle {
    Point c;
    double r;
    Circle(Point c = Point(), double r = 0.0): c(c), r(r) {}
};

double arg(Vector p) { return std::atan2(p.y, p.x); }
Vector polar(double a, double r) { return Point(std::cos(r) * a, std::sin(r) * a); }

std::pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
    double d = (c1.c - c2.c).abs();
    double a = std::acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
    double t = arg(c2.c - c1.c);
    return std::make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n; cin >> n;
    V< P<double, double> > xy(n);
    for (int i = 0; i < n; i++) cin >> xy[i].first >> xy[i].second;
    double low = 0, high = 2000;
    for (int _ = 0; _ < 100; _++) {
        double mid = (low + high) / 2.0;
        V<Circle> cir(n);
        for (int i = 0; i < n; i++) cir[i] = Circle(Point(xy[i].first, xy[i].second), mid);
        V<Point> crp;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (cir[i].r + cir[j].r < (cir[i].c - cir[j].c).abs()) continue;
                P<Point, Point> tmpp = getCrossPoints(cir[i], cir[j]);
                crp.emplace_back(tmpp.first);
                crp.emplace_back(tmpp.second);
            }
        }
        if (crp.size() == 0) {
            low = mid;
            continue;
        }

        bool is_r = true;
        for (int i = 0; i < crp.size(); i++) {
            is_r = true;
            for (int j = 0; j < n; j++) {
                if ((crp[i] - Point(xy[j].first, xy[j].second)).abs() - mid > EPS) {
                    // cout << fixed << setprecision(12) << i << ' ' << j << ' ' << (crp[i] - Point(xy[j].first, xy[j].second)).abs() << ' ' << mid << '\n';
                    is_r = false;
                    break;
                }
            }
            if (is_r) break;
        }

        // cout << fixed << setprecision(12) << low << ' ' << high << '\n';
        if (is_r) high = mid;
        else low = mid;
    }
    cout << fixed << setprecision(12) << low << '\n';
    return 0;
}


Measured memory_bytes: 512