import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;

enum EPS = 1e-10;

///
double add(double a, double b) {
    if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
    return a + b;
}

///
struct P {
    double x, y;

    this(double x, double y) {
        this.x = x;
        this.y = y;
    }

    P opBinary(string op)(P p) {
        static if (op == "+") return P(add(x, p.x), add(y, p.y));
        else static if (op == "-") return P(add(x, -p.x), add(y, -p.y));
        else static assert(0, "Operator '"~op~"' not implemented");
    }

    P opBinary(string op)(double d) {
        static if (op == "*") return P(x * d, y * d);
        else static if (op == "/") return P(x / d, y / d);
        else static assert(0, "Operator '"~op~"' not implemented");
    }

    double dot(P p) {
        return add(x * p.x, y * p.y);
    }

    double det(P p) {
        return add(x * p.y, -y * p.x);
    }

    double dist(P p) {
        return sqrt((x - p.x)^^2 + (y - p.y)^^2);
    }

    P middle(P p) {
        return P((x + p.x)/2, (y + p.y)/2);
    }
}

bool is_parallel(P a1, P a2, P b1, P b2) {
    return (a1 - a2).det(b1 - b2) == 0;
}

///
struct Triangle {
    P a, b, c;

    this(P a, P b, P c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    alias Circle = Tuple!(P, "p", double, "r");

    Circle enclosing_circle() {
        auto A = (b-c).dot(b-c);
        auto B = (c-a).dot(c-a);
        auto C = (a-b).dot(a-b);

        auto T = A*(B+C-A);
        auto U = B*(C+A-B);
        auto W = C*(A+B-C);

        auto p = (a*T + b*U + c*W)/(T + U + W);

        return Circle(p, sqrt((a.x - p.x)^^2 + (a.y - p.y)^^2));
    }
}

///
P[] convex_hull(P[] ps)
{
    sort!"a.x == b.x ? a.y < b.y : a.x < b.x"(ps);
    auto n = ps.length;
    size_t k;
    auto qs = new P[](n*2);

    foreach (i; 0..n) {
        while (k > 1 && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) k--;
        qs[k++] = ps[i];
    }

    auto t = k;
    foreach_reverse (i; 0..n-1) {
        while (k > t && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) k--;
        qs[k++] = ps[i];
    }

    qs.length = k;
    return qs;
}

void main()
{
    auto N = readln.chomp.to!int;
    P[] ps;
    foreach (_; 0..N) {
        auto xy = readln.split.to!(double[]);
        ps ~= P(xy[0], xy[1]);
    }
    if (N == 2) {
        writefln("%.010f", sqrt((ps[0].x - ps[1].x)^^2 + (ps[0].y + ps[1].y)^^2) / 2);
        return;
    }
    auto qs = convex_hull(ps)[0..$-1];
    auto len = qs.length;
    double r = 3000.0;
    foreach (i; 0..len-2) {
        foreach (j; i+1..len-1) {
            foreach (k; j+1..len) {
                auto p1 = qs[i], p2 = qs[j], p3 = qs[k];
                if (is_parallel(p1, p2, p1, p3)) continue;
                auto pr = Triangle(p1, p2, p3).enclosing_circle();
                foreach (q; qs) if (pr.p.dist(q) > pr.r) goto ng1;
                r = min(r, pr.r);
                ng1:
            }
        }
    }
    foreach (i; 0..len-1) {
        foreach (j; 0..len) {
            auto p1 = qs[i], p2 = qs[j];
            auto p = P((p1.x + p2.x)/2, (p1.y + p2.y)/2);
            auto d = p1.dist(p2)/2;
            foreach (q; qs) if (p.dist(q) > d) goto ng2;
            r = min(r, d);
            ng2:
        }
    }
    writefln("%.010f", r);
}