/*
void main()
{
    long n = rdElem;
    coord[] p = new coord[n];
    foreach (i; 0 .. n)
    {
        long[] xy = rdRow;
        p[i].x = xy[0], p[i].y = xy[1];
    }


    double rad = 2000 ^^ 2;
    if (n == 2)
    {
        rad = hypot(p[0].x-p[1].x, p[0].y-p[1].y);

    }
    else
    {
        foreach (i; 0 .. n-2)
        {
            foreach (j; i+1 .. n-1)
            {
                foreach (k; j+1 .. n)
                {

                }
            }
        }
    }

    eritefln("%.10f", rad);
}
*/

void main()
{
    long n = rdElem;
    coord[] p = new coord[n];
    foreach (i; 0 .. n)
    {
        double[] xy = rdRow!double;
        p[i].x = xy[0], p[i].y = xy[1];
    }

    double eps = 0.0000001;
    double rad = 2000 ^^ 2;
    foreach (i; 0 .. n-1)
    {
        foreach (j; i+1 .. n)
        {
            bool ok = true;
            double r = hypot(p[i].x-p[j].x, p[i].y-p[j].y) / 2;
            coord o = coord((p[i].x+p[j].x)/2, (p[i].y+p[j].y)/2);
            foreach (k; 0 .. n)
            {
                if (k == i || k == j) continue;
                if (hypot(o.x-p[k].x, o.y-p[k].y) > r + eps)
                {
                    ok = false;
                }
            }
            if (ok) rad = min(rad, r);
        }
    }

    writefln("%.15f", rad);
}

alias Tuple!(double, "x", double, "y") coord;

T rdElem(T = long)()
{
    //import std.stdio : readln;
    //import std.string : chomp;
    //import std.conv : to;

    return readln.chomp.to!T;
}

alias rdStr = rdElem!string;

dchar[] rdDchar()
{
    //import std.conv : to;

    return rdStr.to!(dchar[]);
}

T[] rdRow(T = long)()
{
    //import std.stdio : readln;
    //import std.array : split;
    //import std.conv : to;

    return readln.split.to!(T[]);
}

T[] rdCol(T = long)(long col)
{
    //import std.range : iota;
    //import std.algorithm : map;
    //import std.array : array;

    return iota(col).map!(x => rdElem!T).array;
}

T[][] rdMat(T = long)(long col)
{
    //import std.range : iota;
    //import std.algorithm : map;
    //import std.array : array;

    return iota(col).map!(x => rdRow!T).array;
}

void wrMat(T = long)(T[][] mat)
{
    //import std.stdio : write, writeln;

    foreach (row; mat)
    {
        foreach (j, compo; row)
        {
            compo.write;
            if (j == row.length - 1) writeln;
            else " ".write;
        }
    }
}

import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
import std.typecons;
import std.ascii;
import std.uni;