/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */



// Taken from: https://github.com/bqi343/USACO/blob/master/Implementations/content/contest/templateShort.cpp

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<ull> vul;
typedef vector<ll> vl;
typedef vector<pi> vpi;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i,0,a)
#define ROF(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i, a) ROF(i,0,a)
#define trav(a, x) for (auto& a: x)

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

#define mp make_pair
#define pb push_back
#define f first
#define s second

const int MOD = 1e9 + 7; // 998244353; // = (119<<23)+1
const int MX = 2e5 + 5;

template<class T>
bool ckmin(T &a, const T &b) {
    return a > b ? a = b, 1 : 0;
}

template<class T>
bool ckmax(T &a, const T &b) {
    return a < b ? a = b, 1 : 0;
}

mt19937 rng((uint32_t) chrono::steady_clock::now().time_since_epoch().count());


//
// Created by aryssoncf on 28/10/2019.
//

#include <type_traits>


#include <iterator>
#include <utility>

template<typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
    return true;
}

constexpr bool hasBegin(...) {
    return false;
}

template<typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;


#ifndef JHELPER_EXAMPLE_PROJECT_IO_HPP
#define JHELPER_EXAMPLE_PROJECT_IO_HPP

#endif //JHELPER_EXAMPLE_PROJECT_IO_HPP

template<typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
    for (T &element: vec) {
        is >> element;
    }
    return is;
}

template<typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    is >> p.first;
    is >> p.second;
    return is;
}

template<class X, class Y>
std::ostream &operator<<(std::ostream &os, std::pair<X, Y> const &p) {
    return os << p.first << " " << p.second;
}

template<class Ch, class Tr, class Container>
std::basic_ostream<Ch, Tr> &operator<<(std::basic_ostream<Ch, Tr> &os, Container const &x) {
    bool first = true;
    for (auto &y : x) {
        if (first) {
            first = false;
        } else {
            os << " ";
        }
        os << y;
    }
    return os;
}

using namespace std;

/*
PROG:
LANG: C++
*/

typedef long double T;

int sgn(T x) { return (x > 0) - (x < 0); }

T sq(T x) { return x * x; }

namespace Point {
    typedef pair<T, T> P;
    typedef vector<P> vP;

    T norm(const P &x) { return sq(x.f) + sq(x.s); }

    T abs(const P &x) { return sqrt(norm(x)); }

    T angle(const P &x) { return atan2(x.s, x.f); }

    P conj(const P &x) { return P(x.f, -x.s); }

    P perp(const P &x) { return P(-x.s, x.f); }

    P dir(T ang) { return P(cos(ang), sin(ang)); }

    P operator-(const P &l) { return P(-l.f, -l.s); }

    P operator+(const P &l, const P &r) {
        return P(l.f + r.f, l.s + r.s);
    }

    P operator-(const P &l, const P &r) {
        return P(l.f - r.f, l.s - r.s);
    }

    P operator*(const P &l, const T &r) {
        return P(l.f * r, l.s * r);
    }

    P operator*(const T &l, const P &r) { return r * l; }

    P operator/(const P &l, const T &r) {
        return P(l.f / r, l.s / r);
    }

    P operator*(const P &l, const P &r) {
        return P(l.f * r.f - l.s * r.s, l.s * r.f + l.f * r.s);
    }

    P operator/(const P &l, const P &r) {
        return l * conj(r) / norm(r);
    }

    P &operator+=(P &l, const P &r) { return l = l + r; }

    P &operator-=(P &l, const P &r) { return l = l - r; }

    P &operator*=(P &l, const T &r) { return l = l * r; }

    P &operator/=(P &l, const T &r) { return l = l / r; }

    P &operator*=(P &l, const P &r) { return l = l * r; }

    P &operator/=(P &l, const P &r) { return l = l / r; }

    P unit(const P &x) { return x / abs(x); }

    T dot(const P &a, const P &b) { return a.f * b.f + a.s * b.s; }

    T cross(const P &a, const P &b) { return a.f * b.s - a.s * b.f; }

    T cross(const P &p, const P &a, const P &b) {
        return cross(a - p, b - p);
    }

    P rotate(const P &a, T b) { return a * P(cos(b), sin(b)); }

    P reflect(const P &p, const P &a, const P &b) {
        return a + conj((p - a) / (b - a)) * (b - a);
    }

    P foot(const P &p, const P &a, const P &b) {
        return (p + reflect(p, a, b)) / (T) 2;
    }

    bool onSeg(const P &p, const P &a, const P &b) {
        return cross(a, b, p) == 0 && dot(p - a, p - b) <= 0;
    }
};
using namespace Point;

class FEncloseAll {
    typedef pair<P, T> circ;

    bool on(circ x, P y) { return abs(y - x.f) == x.s; }

    bool in(circ x, P y) { return abs(y - x.f) <= x.s; }

    T arcLength(circ x, P a, P b) {
        P d = (a - x.f) / (b - x.f);
        return x.s * acos(d.f);
    }

    circ ccCenter(P a, P b, P c) {
        b -= a;
        c -= a;
        P res = b * c * (conj(c) - conj(b)) / (b * conj(c) - conj(b) * c);
        return {a + res, abs(res)};
    }

    circ mec(vP ps) {
        shuffle(all(ps), rng);
        P o = ps[0];
        T r = 0, EPS = 1 + 1e-8;
        F0R(i, sz(ps)) if (abs(o - ps[i]) > r * EPS) {
                o = ps[i], r = 0;
                F0R(j, i) if (abs(o - ps[j]) > r * EPS) {
                        o = (ps[i] + ps[j]) / 2, r = abs(o - ps[i]);
                        F0R(k, j) if (abs(o - ps[k]) > r * EPS)
                                tie(o, r) = ccCenter(ps[i], ps[j], ps[k]);
                    }
            }
        return {o, r};
    }

public:
    void solve(std::istream &in, std::ostream &out) {
        int n;
        in >> n;
        vP points(n);
        in >> points;
        circ res = mec(points);
        out << fixed << setprecision(12) << res.s << "\n";
    }

    void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
    FEncloseAll solver;
    solver.setup();
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
    solver.solve(in, out);
    return 0;
}


Measured memory_bytes: 256