#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <random>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>

using namespace std;

typedef long double ld;

const ld eps = 1e-9;

struct Point {
    ld x, y;

    Point(ld x_, ld y_) : x(x_), y(y_) {}


    Point() {}

    ld operator*(const Point &other) const {
        return x * other.y - y * other.x;
    }

    Point operator/(const ld to) const {
        return Point(x / to, y / to);
    }

    Point operator*(const ld to) const {
        return Point(x * to, y * to);
    }

    Point operator-(const Point &other) const {
        return Point(x - other.x, y - other.y);
    }

    Point operator+(const Point &other) const {
        return Point(x + other.x, y + other.y);
    }

    ld dist(const Point &other) const {
        return hypot(x - other.x, y - other.y);
    }

    Point norm() {
        return Point(-y, x);
    }
};

Point intersect(const Point &a, const Point &b, const Point &c, const Point &d) {
    ld s1 = (c - a) * (d - a);
    ld s2 = (d - b) * (c - b);
    ld s = s1 + s2;
    Point v = b - a;
    v = v / s;
    v = v * s1;
    return a + v; 
}

void get_sp(const Point &a, const Point &b, Point &f, Point &s) {
    Point np = b - a;
    np = np / 2;
    f = a + np;
    np = np.norm();
    s = f + np;
}

void get_2(const Point &a, const Point &b, Point &to, ld &r) {
    Point np = b - a;
    np = np / 2;
    to = a + np;
    r = to.dist(a);
}

void get_3(const Point &a, const Point &b, const Point &c, Point &to, ld &r) {
    Point p1, p2;
    Point t1, t2;
    get_sp(a, b, p1, p2);
    get_sp(a, c, t1, t2);
    to = intersect(p1, p2, t1, t2);
    r = to.dist(a);
} 

bool inside(const Point &cen, ld r, const Point &t) {
    return cen.dist(t) < r + eps;
}

pair<Point, ld> rec(vector<Point> points, vector<Point> border) {
    Point cen;
    ld r;
    if ((int)border.size() == 3) {
        get_3(border[0], border[1], border[2], cen, r);
        return {cen, r};
    }
    vector<Point> nb = border;
    for (int i = 0; (int)nb.size() < 2; i++) {
        nb.push_back(points[i]);
    }
    get_2(nb[0], nb[1], cen, r);
    for (int i = 0; i < (int)points.size(); i++) {
        if (!inside(cen, r, points[i])) {
            vector<Point> rb = border;
            rb.push_back(points[i]);
            auto nw = rec(vector<Point> (points.begin(), points.begin() + i), rb);
            tie(cen, r) = nw;
        }
    }
    return {cen, r};
}

mt19937 rng(239);

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    cout << fixed << setprecision(16);

    int n;
    cin >> n;
    vector<Point> a(n);
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        a[i] = Point(x, y);
    }
    if (n == 1) {
        cout << a[0].x << ' ' << a[0].y << endl;
        cout << 0 << endl;
        exit(0);
    }
    shuffle(a.begin(), a.end(), rng);
    vector<Point> emp;
    auto res = rec(a, emp);
    Point cen = res.first;
    ld r = res.second;
    // cout << cen.x << ' ' << cen.y << endl;
    cout << r << endl;
}


Measured memory_bytes: 256