import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.stdio;

struct Point {
    int x;
    int y;
}

struct PointF {
    real x;
    real y;
}

int dist2(Point p1, Point p2) {
    return (p1.x - p2.x) ^^ 2 + (p1.y - p2.y) ^^ 2;
}

bool eikaku(Point p1, Point p2, Point p3) {
    auto a = dist2(p1, p2);
    auto b = dist2(p2, p3);
    auto c = dist2(p3, p1);
    if (a > b) swap(a, b);
    if (b > c) swap(b, c);
    if (a > b) swap(a, b);
    return c >= a + b;
}

real dist(Point p1, PointF p2) {
    return sqrt((p1.x - p2.x)^^2 + (p1.y - p2.y)^^2);
}


void main() {
    auto N = readln.chomp.to!int;
    auto P = new Point[](N);
    foreach (i; 0..N) {
        auto s = readln.split.map!(to!int);
        auto x = s[0];
        auto y = s[1];
        P[i] = Point(x, y);
    }

    if (N == 2) {
        real ans = sqrt(to!real((P[0].x - P[1].x) ^^ 2 + (P[0].y - P[1].y) ^^ 2)) / 2;
        writefln("%.15f", ans);
        return;
    }

    real check(PointF center, real radius) {
        return P.map!(p => dist(p, center) <= radius).all;
    }

    foreach (i; 0..N) foreach (j; i+1..N) foreach (k; j+1..N) {
        PointF center;
        real radius;
        if (P[i].x == P[j].x && P[i].x == P[k].x) {
            real maxy = max(P[i].y, P[j].y, P[k].y);
            real miny = min(P[i].y, P[j].y, P[k].y);
            center.x = P[i].x;
            center.y = (maxy - miny) / 2;
            radius = maxy - miny;
        } else if (P[i].y == P[j].y && P[i].y == P[k].y) {
            real maxx = max(P[i].x, P[j].x, P[k].x);
            real minx = min(P[i].x, P[j].x, P[k].x);
            center.y = P[i].y;
            center.x = (maxx - minx) / 2;
            radius = maxx - minx;
        } else if (eikaku(P[i], P[j], P[k])) {
            real a = P[i].x;
            real b = P[i].y;
            real c = P[j].x;
            real d = P[j].y;
            real e = P[k].x;
            real f = P[k].y;
            center.y = ((e - a) * (a * a + b * b - c * c - d * d) - (c - a) * (a * a + b * b - e * e - f * f)) / (2 * (e - a) * (b - d) - 2 * (c - a) * (b - f));
            if (c != a) {
                center.x = (2 * (b - d) * center.y - a * a - b * b + c * c + d * d) / (2 * (c - a));
            } else {
                center.x = (2 * (b - f) * center.y - a * a - b * b + e * e + f * f) / (2 * (e - a));
            }
            radius = sqrt((a - center.x) ^^ 2 + (b - center.y) ^^ 2);
        } else {
            auto a = dist2(P[i], P[j]);
            auto b = dist2(P[j], P[k]);
            auto c = dist2(P[k], P[i]);
            Point q1;
            Point q2;
            if (a >= b && a >= c) {
                q1 = P[i];
                q2 = P[j];
            } else if (b >= a && b >= c) {
                q1 = P[j];
                q2 = P[k];
            } else {
                q1 = P[k];
                q2 = P[i];
            }
            center.x = (q1.x + q2.x) / 2.0L;
            center.y = (q1.y + q2.y) / 2.0L;
            radius = sqrt((P[i].x - center.x) ^^ 2 + (P[i].y - center.y) ^^ 2);
        }
        if (check(center, radius)) {
            writefln("%.15f", radius);
            return;
        }
    }
}