#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#include<complex>

#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)

template<typename T1, typename T2>
inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }

template<typename T1, typename T2>
inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }

typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0
#define dump(x)  cerr << #x << " = " << (x) << endl
#define MOD 1000000007

#define EPS (1e-9)
using Double = long double;
typedef complex<Double> P; // P:点
struct C { //C:円
    P p;
    Double r;

    C() : p(0), r(0) {}

    C(const P &p, Double r) : p(p), r(r) {};
};

bool interectCC(const C &c, const C &d) {
    return (norm(c.p - d.p) - (c.r + d.r) * (c.r + d.r) < EPS) &&
           (norm(c.p - d.p) - (c.r - d.r) * (c.r - d.r) > -EPS);
}

pair<P, P> crosspointCC(const C &c, const C &q) {
    P a = conj(q.p - c.p);
    P b = q.r * q.r - c.r * c.r - (q.p - c.p) * a;
    P C = c.r * c.r * (q.p - c.p);
    P d = b * b - 4.0l * a * C;
    P z1 = (-b * sqrt(d)) / (2.0l * a) + c.p;
    P z2 = (-b - sqrt(d)) / (2.0l * a) + c.p;
    return pair<P, P>(z1, z2);
}


//edit

class Solve {
public:
    Int n;
    vector<P> pts;

    bool check(Double r) {
        int ans = 1;
        for (int i = 0; i < n; i++) {
            C c1 = C(pts[i], r);
            for (int j = 0; j < i; j++) {
                C c2 = C(pts[j], r);
                if (interectCC(c1, c2)) {
                    pair<P, P> nnr = crosspointCC(c1, c2);
                    int ret = 0, rec = 0;
                    for (int k = 0; k < n; k++) {
                        if (abs(nnr.first - pts[k]) <= r + EPS) ret++;
                        if (abs(nnr.second - pts[k]) <= r + EPS) rec++;
                    }
                    ans = max(ans, max(ret, rec));
                }
            }
        }
        return ans >= n;
    }

    void solve() {
        cin >> n;
        pts.resize(n);
        for (int i = 0; i < n; ++i) {
            Double a, b;
            cin >> a >> b;
//            cin >> pts[i].real() >> pts[i].imag();
//            pts[i].real() = a;
//            pts[i].imag() = b;
            pts[i] = {a, b};
        }

        Double lb = 0.0, ub = 2e3;
//        Double lb = 0.0, ub = 1e1;

        for (int i = 0; i < 100; ++i) {
            Double mid = (lb + ub) / 2.0;
            if (check(mid)) {
                ub = mid;
            } else {
                lb = mid;
            }
        }

        cout << ub << endl;


    }
};


int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);

    Solve().solve();


    return 0;
}


Measured memory_bytes: 384