/*

题意：给你散落的点，让你求出最小的圆，将这些点围起来，点可以在圆上，输出圆的最小半径。

初步思路：求出凸包，然后在求出这个凸包的外接圆，两条边的垂直平分线的交点就是圆心

#错误：有点天真，三角形一定有外接圆，但是多边形不一定有外接圆

#改进：求出凸包，然后求凸包的最小覆盖圆，这个名词也是看到博客才知道了（呜呜呜，又少了

       一次好好动脑的机会）然后任意的三个点组成的三角形的外接圆的最大半径就是就是凸包

       “外接圆”的半径了，三角形的外接圆半径为abc/4s，这个公式能简单的证明。遍历出所有的半径，中间最长的半径

       就是要求的半径。

#改进错误点：上面的情况只适用于锐角三角形，钝角，直角三角形的“外接圆”的最小半径，不是外接圆的半径，而是最长边的一半！

*/

#include<bits/stdc++.h>

using namespace std;

/****************************凸包模板*******************************/

const double eps = 1e-;

int sgn(double x)

{

    if(fabs(x) < eps)return ;

    if(x < )return -;

    else return ;

}

struct Point

{

    double x,y;

    Point(){}

    Point(double _x,double _y)

    {

        x = _x;y = _y;

    }

    Point operator -(const Point &b)const

    {

        return Point(x - b.x,y - b.y);

    }

    //叉积

    double operator ^(const Point &b)const

    {

        return x*b.y - y*b.x;

    }

    //点积

    double operator *(const Point &b)const

    {

        return x*b.x + y*b.y;

    }

    void input(){

        scanf("%lf%lf",&x,&y);

    }

};

struct Line {

    Point s,e;

    Line(){}

    Line(Point _s,Point _e) {

        s = _s; e = _e;

    }

};

//*两点间距离

double dist(Point a,Point b)

{

    return sqrt((a-b)*(a-b));

}

/*

* 求凸包，Graham算法

* 点的编号0~n-1

* 返回凸包结果Stack[0~top-1]为凸包的编号

*/

const int MAXN = ;

Point List[MAXN];

int Stack[MAXN];//用来存放凸包的点

int top;//表示凸包中点的个数

//相对于List[0]的极角排序

bool _cmp(Point p1,Point p2)

{

    double tmp = (p1-List[])^(p2-List[]);

    if(sgn(tmp) > )

        return true;

    else if(sgn(tmp) ==  && sgn(dist(p1,List[]) - dist(p2,List[])) <= )

        return true;

    else

        return false;

}

void Graham(int n)

{

    Point p0;

    int k = ;

    p0 = List[];

    //找最下边的一个点

    for(int i = ;i < n;i++)

    {

        if( (p0.y > List[i].y) || (p0.y == List[i].y && p0.x > List[i].x) )

        {

            p0 = List[i];

            k = i;

        }

    }

    swap(List[k],List[]);

    sort(List+,List+n,_cmp);

    if(n == )

    {

        top = ;

        Stack[] = ;

        return;

    }

    if(n == )

    {

        top = ;

        Stack[] = ;

        Stack[] = ;

        return ;

    }

    Stack[] = ;

    Stack[] = ;

    top = ;

    for(int i = ;i < n;i++)

    {

        while(top >  && sgn((List[Stack[top-]]-List[Stack[top-]])^(List[i]-List[Stack[top-]])) <= )

            top--;

        Stack[top++] = i;

    }

}

/****************************凸包模板*******************************/

int n;

int main(){

    // freopen("in.txt","r",stdin);

    while(scanf("%d",&n)!=EOF&&n){

        for(int i=;i<n;i++){

            List[i].input();

        }//输入所有点坐标

        if(n==){

            printf("0.50\n");

            continue;

        }

        if(n==){

            printf("%.2lf\n",dist(List[],List[])/+0.5);

            continue;

        }

        Graham(n);//求出凸包

        double Maxr=-1.0;

        // cout<<top<<endl;

        //将Static[0]作为所有小三角形的公共顶点

        for(int i=;i<top;i++){//枚举三角形的点

            for(int j=i+;j<top;j++){

                for(int k=j+;k<top;k++){

                    /*

                    三条边的长度

                    */

                    double a=dist(List[Stack[i]],List[Stack[j]]);

                    double b=dist(List[Stack[i]],List[Stack[k]]);

                    double c=dist(List[Stack[k]],List[Stack[j]]);

                    if(a*a+b*b<c*c||a*a+c*c<b*b||b*b+c*c<a*a){//判断是不是锐角三角形

                        Maxr=max(Maxr,max(max(a,b),c)/);

                    }else{

                        /*

                        三角形的面积

                        */

                        Point x1=List[Stack[j]]-List[Stack[i]];

                        Point x2=List[Stack[k]]-List[Stack[i]];

                        double s=fabs(x1^x2)/;

                        Maxr=max(Maxr,(a*b*c)/(*s));

                    }

                }

            }

        }

        printf("%.2lf\n",Maxr+0.5);

    }

    return ;

}