#pragma GCC optimize("Ofast,fast-math,unroll-loops")

#include <bits/stdc++.h>

//#define ll ll
//#define double long double
#define endl '\n'
#define all(C) (C).begin(), (C).end()
#define rall(C) (C).rbegin(), (C).rend()
#define mp make_pair 
#define pb emplace_back
#define dbg(x) cerr << #x << " : " << x << endl
//#define PI 3.141592653589

using namespace std;
       
using ll = long long;
using ull = unsigned long long;
using ld = long double;
       
/* 
const ll MAX_MEM = 25e7;
char MEM[MAX_MEM];
ll MEM_POS = 0;
void* operator new(size_t x)
{
    auto ret = MEM + MEM_POS;
    MEM_POS += x;
    assert(MEM_POS < MAX_MEM);
    return ret;
}
void operator delete(void*)
{}
*/
       
template <class T>
istream& operator>> (istream &in, vector <T> &a)
{
    for (auto &i : a)
        in >> i;
    return in;
}
       
template <class T> 
ostream& operator<< (ostream &out, vector <T> a)
{
    for (auto &i : a)
        out << i << ' ';
    return out;
}
       
template <class T, class U>
istream& operator>> (istream &in, pair <T, U> &p)
{
    in >> p.first >> p.second;
    return in;
}
       
template <class T, class U>
ostream& operator<< (ostream &out, pair <T, U> p)
{
    out << p.first << " " << p.second << " ";
    return out;
}
       
inline void Start()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    //freopen("circlecover.in", "r", stdin);
    //freopen("circlecover.out", "w", stdout);
}

const ld EPS = 1e-7;
struct point
{
    ld x, y;
    point() {}
    point(ld x, ld y) : x(x), y(y) {}
    ld operator * (const point p) const
    {
        return x * p.x + y * p.y;
    }
    ld operator % (const point p) const
    {
        return x * p.y - y * p.x;
    }
    point operator + (const point p) const
    {
        return point(x + p.x, y + p.y);
    }
    point operator - (const point p) const
    {
        return point(x - p.x, y - p.y);
    }
    ld operator! ()
    {
        return sqrtl(x * x + y * y);
    }
    friend istream& operator >> (istream &in, point &a)
    {
        in >> a.x >> a.y;
        return in;
    }
    friend ostream& operator << (ostream &in, point a)
    {
        in << a.x << " " << a.y;
        return in;
    }
};
vector <point> convex(vector <point> p)
{
    int n = p.size();
    sort(all(p), [] (point a, point b) {return a.x < b.x || (a.x == b.x && a.y < b.y);});
    vector <point> fs, sc;
    for (int i = 0; i < n; ++i)
    {
        while (fs.size() > 1)
        {
            point c = p[i], b = fs.back();
            fs.pop_back();
            point a = fs.back();
            if ((b - a) % (c - b) == 0)
                continue;
            if ((b - a) % (c - b) < 0)
            {
                fs.pb(b);
                break;
            }
        }
        fs.pb(p[i]);
    }
    for (int i = n - 1; i >= 0; --i)
    {
        while (sc.size() > 1)
        {
            point c = p[i], b = sc.back();
            sc.pop_back();
            point a = sc.back();
            if ((b - a) % (c - b) == 0)
                continue;
            if ((b - a) % (c - b) < 0)
            {
                sc.pb(b);
                break;
            }
        }
        sc.pb(p[i]);
    }
    for (int i = 1; i < (int)sc.size() - 1; ++i)
        fs.pb(sc[i]);
    return fs;
}
ld height(point p, point a, point b)
{
    return ((p - a) % (b - a)) / !(b - a);
}
struct circle
{
    point p;
    ld r;
    circle() {}
    circle(point p, ld r) : p(p), r(r) {}
    circle(point a, point b)
    {
        p = a + b, p.x /= 2.0, p.y /= 2.0;
        r = !(b - a);
        r /= 2.0;
    }
    circle(point a, point b, point c)
    {
        point bs = b - a, cs = c - a;
        ld ds = 2.0 * (bs.x * cs.y - bs.y * cs.x);
        p.x = (cs.y * (bs.x * bs.x + bs.y * bs.y) - bs.y * (cs.x * cs.x + cs.y * cs.y)) / ds;
        p.y = (bs.x * (cs.x * cs.x + cs.y * cs.y) - cs.x * (bs.x * bs.x + bs.y * bs.y)) / ds;
        p = p + a;
        r = !(p - a);
    }
    bool check(point a)
    {
        return (!(p - a)) <= r + EPS;
    }
    friend ostream& operator<< (ostream &in, circle c)
    {
        in << c.p << endl << c.r;
        return in;
    }
};

mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
//mt19937 mt(2004);
circle f2(vector <point>, point);
circle f3(vector <point>, point, point);
circle f1(vector <point> p)
{
    shuffle(all(p), mt);
    circle c(p[0], p[1]);
    for (int i = 2; i < p.size(); ++i)
    {
        if (c.check(p[i]))
            continue;
        vector <point> ps;
        for (int j = 0; j <= i; ++j)
            ps.pb(p[j]);
        c = f2(ps, p[i]);
    }
    return c;
}
circle f2(vector <point> p, point a)
{
    shuffle(all(p), mt);
    circle c(p[0], a);
    for (int i = 1; i < p.size(); ++i)
    {
        if (c.check(p[i]))
            continue;
        vector <point> ps;
        for (int j = 0; j <= i; ++j)
            ps.pb(p[j]);
        c = f3(ps, a, p[i]);
    }
    return c;
}
circle f3(vector <point> p, point a, point b)
{
    shuffle(all(p), mt);
    circle c(a, b);
    for (int i = 0; i < p.size(); ++i)
    {
        if (c.check(p[i]))
            continue;
        c = circle(a, b, p[i]);
    }
    return c;
}

signed main()
{
    Start();
    int n;
    cin >> n;
    vector <point> p(n);
    cin >> p;
    shuffle(all(p), mt);
    circle c;
    if (n == 1)
        c = circle(p[0], 0.0);
    else if (n == 2)
        c = circle(p[0], p[1]);
    else
        c = f1(p);
    cout << setprecision(15) << fixed << c.r;
    return 0;
}



Measured memory_bytes: 256