#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)
int cmp(double a ,double b = 0){
    return a + EPS < b ? -1: a - EPS > b ? 1:0;
}

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(cmp(dot(b-a,c-a)) <= 0) return 0;
    if(cmp(dot(a-b,c-b)) <= 0) return 0;
    if(cmp(dot(a-c,b-c)) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,plano[i]) <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);

        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

            sort(planoint,planoint+n);
            for(int a = 0; a < n; ++a)
                for(int b = a + 1; b < n; ++b)
                    for(int c = b + 1; c < n ; ++c)
                        {   double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);
                        }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(c == ii(a.first,a.second + lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,a.second));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,point(planoint[i].first,planoint[i].second)) < radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        sort(planoint,planoint+n);
        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                     double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);

                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) < radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,point(planoint[i].first,planoint[i].second)) + EPS <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        sort(planoint,planoint+n);
        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                     double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);

                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)
inline int cmp(double a ,double b = 0){
    return a + EPS < b ? -1: a - EPS > b ? 1:0;
}

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    double mod2() { return x*x + y*y; }
    double mod()  { return sqrt(x*x + y*y); }
    double arg()  { return atan2(y, x); }
    point ort()   { return point(-y, x); }
    point unit()  { double k = mod(); return point(x/k, y/k); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }

bool operator ==(const point &a, const point &b)
{
    return cmp(a.x,b.x)==0 && cmp(a.y,b.y) == 0;
}
bool operator !=(const point &a, const point &b)
{
    return !(a==b);
}
bool operator <(const point &a, const point &b)
{   if(cmp(a.x,b.x)) return cmp(a.x,b.x) < 0;
    return cmp(a.y,b.y) < 0;
}

//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

point RotateCCW(point p, double t) { //rota t radianes antihorario
  return point(p.x*cos(t)-p.y*sin(t), p.x*sin(t)+p.y*cos(t));
}
// Heron triangulo y cuadrilatero ciclico
// http://mathworld.wolfram.com/CyclicQuadrilateral.html
// http://www.spoj.pl/problems/QUADAREA/

double areaHeron(double a, double b, double c)
{
    double s = (a + b + c) / 2;
    return sqrt(s * (s-a) * (s-b) * (s-c));
}

double circumradius(double a, double b, double c) { return a * b * c / (4 * areaHeron(a, b, c)); }

double areaHeron(double a, double b, double c, double d)
{
    double s = (a + b + c + d) / 2;
    return sqrt((s-a) * (s-b) * (s-c) * (s-d));
}

double circumradius(double a, double b, double c, double d) { return sqrt((a*b + c*d) * (a*c + b*d) * (a*d + b*c))  / (4 * areaHeron(a, b, c, d)); }

//### DETERMINA SI P PERTENECE AL SEGMENTO AB ###########################################
bool between(const point &A, const point &B, const point &P)
{
    return  P.x + EPS >= min(A.x, B.x) && P.x <= max(A.x, B.x) + EPS &&
            P.y + EPS >= min(A.y, B.y) && P.y <= max(A.y, B.y) + EPS;
}

bool onSegment(const point &A, const point &B, const point &P)
{
    return abs(area(A, B, P)) < EPS && between(A, B, P);
}

//### DETERMINA SI EL SEGMENTO P1Q1 SE INTERSECTA CON EL SEGMENTO P2Q2 #####################
//funciona para cualquiera P1, P2, P3, P4
bool intersects(const point &P1, const point &P2, const point &P3, const point &P4)
{
    double A1 = area(P3, P4, P1);
    double A2 = area(P3, P4, P2);
    double A3 = area(P1, P2, P3);
    double A4 = area(P1, P2, P4);

    if( ((A1 > 0 && A2 < 0) || (A1 < 0 && A2 > 0)) &&
        ((A3 > 0 && A4 < 0) || (A3 < 0 && A4 > 0)))
            return true;

    else if(A1 == 0 && onSegment(P3, P4, P1)) return true;
    else if(A2 == 0 && onSegment(P3, P4, P2)) return true;
    else if(A3 == 0 && onSegment(P1, P2, P3)) return true;
    else if(A4 == 0 && onSegment(P1, P2, P4)) return true;
    else return false;
}

//### DETERMINA SI A, B, M, N PERTENECEN A LA MISMA RECTA ##############################
bool sameLine(point P1, point P2, point P3, point P4)
{
    return area(P1, P2, P3) == 0 && area(P1, P2, P4) == 0;
}
//### SI DOS SEGMENTOS O RECTAS SON PARALELOS ###################################################
bool isParallel(const point &P1, const point &P2, const point &P3, const point &P4)
{
    return cross(P2 - P1, P4 - P3) == 0;
}

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

point circumcenter(const point &A, const point &B, const point &C)
{
    return (A + B + (A - B).ort() * dot(C - B, A - C) / cross(A - B, A - C)) / 2;
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,plano[i]) <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);

        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

            sort(planoint,planoint+n);
            for(int a = 0; a < n; ++a)
                for(int b = a + 1; b < n; ++b)
                    for(int c = b + 1; c < n ; ++c)
                        {   double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);
                        }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,plano[i]) + EPS <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                     double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);

                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,plano[i]) + EPS <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

            sort(planoint,planoint+n);
            for(int a = 0; a < n; ++a)
                for(int b = a + 1; b < n; ++b)
                    for(int c = b + 1; c < n ; ++c)
                        {   double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);
                        }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(dot(b-a,c-a) <= 0) return 0;
    if(dot(a-b,c-b) <= 0) return 0;
    if(dot(a-c,b-c) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(c == ii(a.first,a.second + lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,a.second));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,point(planoint[i].first,planoint[i].second)) + EPS < radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        sort(planoint,planoint+n);
        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                     double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);

                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS < radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

        printf("%.10f\n",res);
    return 0;
}


#include <bits/stdc++.h>
#define inf 10000
using namespace std;
#define EPS 1e-9
#define PI acos(-1)
int cmp(double a ,double b = 0){
    return a + EPS < b ? -1: a - EPS > b ? 1:0;
}

struct point
{
    double x, y;
    point(){}
    point(double a, double b) { x = a; y = b; }
    point ort()   { return point(-y, x); }
};

point operator +(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
point operator -(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
point operator /(const point &a, double k) { return point(a.x/k, a.y/k); }
point operator *(const point &a, double k) { return point(a.x*k, a.y*k); }
//### FUNCIONES BASICAS #############################################################

double dist(const point &A, const point &B)    { return hypot(A.x - B.x, A.y - B.y); }
double cross(const point &A, const point &B) { return A.x * B.y - A.y * B.x; }
double dot(const point &A, const point &B)   { return A.x * B.x + A.y * B.y; }
double area(const point &A, const point &B, const point &C) { return cross(B - A, C - A); }

//### PUNTO DE INTERSECCION DE DOS RECTAS NO PARALELAS #################################
point lineIntersection(const point &A, const point &B, const point &C, const point &D)
{
    return A + (B - A) * (cross(C - A, D - C) / cross(B - A, D - C));
}

bool valid(const point &a,const point &b,const point &c){
    if(cmp(dot(b-a,c-a)) <= 0) return 0;
    if(cmp(dot(a-b,c-b)) <= 0) return 0;
    if(cmp(dot(a-c,b-c)) <= 0) return 0;
    return 1;
}

point get(const point &a,const point &b,const point &c){
    point mid1 = (a + b)/2; point dir1 = (b - a);
    point mid2 = (a + c)/2; point dir2 = (c - a);
    return lineIntersection(mid1,mid1 + dir1.ort()*inf,mid2,mid2 + dir2.ort()*inf);
}
#define ii pair<int,int>
#define sz 10005
point plano[123];
ii planoint[123];
int n;
bool dif(ii a,ii b){
    return a.first != b.first && a.second != b.second;
}

bool found (ii a,int &last){
    for(int i = 0; i < n; ++i)
        if(planoint[i] == a) {last = i; return 1;}
    return 0;
}
double valid(int x,int y,int z){
    ii a = planoint[x] , b = planoint[y] , c = planoint[z];

    if(!dif(a,b)) return -1.0;
    if(abs(a.first - b.first) != abs(a.second - b.second)) return -1.0;
    int lado = abs(a.first - b.first);

    if(a.second > b.second) swap(a,b);

    bool ok = 0;
    int last;
    if(c == ii(a.first + lado,a.second) && found(ii(a.first,a.second+lado),last) ) ok = 1;
    if(!ok && c == ii(a.first,b.second+lado) && found(ii(a.first+lado,a.second),last) ) ok = 1;
    if(!ok) return -1.0;

    point mid = point((a.first + b.first) / 2.0 , (a.second + b.second) / 2.0);
    double radio = dist(mid,point(a.first,b.first));
    for(int i = 0; i < n; ++i)
        if(i!= x && i!= y && i!= z && i!=last && dist(mid,plano[i]) + EPS <= radio) return -1.0;
    return radio;
}

int main(){
 //freopen("in.c","r",stdin);

        int x,y;
        scanf("%d",&n);
        for(int i = 0; i < n; ++i){
            scanf("%d %d",&x,&y);
            plano[i] = point(x,y);
            planoint[i] = ii(x,y);
        }

        double res = -1;
        for(int a = 0; a < n; ++a)
            for(int b = a + 1; b < n; ++b)
                for(int c = b + 1; c < n ; ++c){
                    if(!valid(plano[a],plano[b],plano[c])) continue; // acutangulo

                    point circunradio = get(plano[a],plano[b],plano[c]);
                    double radio = dist(circunradio,plano[a]);
                    bool covered = 0;
                        for(int i = 0; i < n; ++i)
                            if(i!=a && i!=b && i!=c && dist(circunradio,plano[i]) + EPS <= radio)
                            {covered = 1; break;}
                    if(!covered)
                    res = max(res,radio);
                }

            sort(planoint,planoint+n);
            for(int a = 0; a < n; ++a)
                for(int b = a + 1; b < n; ++b)
                    for(int c = b + 1; c < n ; ++c)
                        {   double p = valid(a,b,c);
                            if(p > 0)
                            res = max(res,p);

                            p = valid(a,c,b);
                            if( p > 0)
                            res = max(res,p);

                            p = valid(b,c,a);
                            if(p > 0)
                            res = max(res,p);
                        }

        printf("%.10f\n",res);
    return 0;
}


#include <cmath>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

#define rep(I,L,R) for(int I=(L),I##_E=(R);I<=I##_E;++I)

//{{{ Geometry Template...
#define Px first
#define Py second

typedef long double LD;
const LD eps = 1e-10, infcmp = 1e200, infcrd = 1e9; // avoid possible errors, infcrd * eps < 1
template <class T> inline T abs (T x) { return x > 0 ? x : -x; }
template <class T> inline int sgn (T x) { return abs(x) < eps ? 0 : x > 0 ? 1 : -1; }
template <class T> inline T sqr (T x) { return x * x; }

struct point
{
	LD x, y;
	point (LD xx = 0, LD yy = 0) { x = xx, y = yy; }
	LD len () { return hypot(x, y); }
	point oppo () { return point(y, -x); }
	point rotate (LD t) { // counterclockwise
		LD cost = cos(t), sint = sin(t);
		return point(x * cost - y * sint, x * sint + y * cost);
	}
};
inline int crdcomp (point s, point e) { int sx = sgn(s.x - e.x); return sx ? sx == -1 : sgn(s.y - e.y) == -1; }
inline point operator+ (const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); }
inline point operator- (const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); }
inline LD operator* (const point &a, const point &b) { return a.x * b.y - b.x * a.y; } // DASH
inline LD operator^ (const point &a, const point &b) { return a.x * b.x + a.y * b.y; } // DOT
inline point operator* (LD l, const point &a) { return point(a.x * l, a.y * l); }
inline point operator* (const point &a, LD l) { return point(a.x * l, a.y * l); }
inline point operator/ (const point &a, LD l) { return (LD(1) / l) * a; }
#ifdef _GLIBCXX_IOSTREAM
inline istream& operator>> (istream &in, point &a) { return in >> a.x >> a.y; }
inline ostream& operator<< (ostream &out, point &a) { return out << '(' << a.x << ',' << a.y << ')'; }
#endif
inline bool operator== (const point &a, const point &b) { return sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0; }

inline bool onSeg (point a, point s, point e) { return sgn((e - a).len() + (a - s).len() - (e - s).len()) == 0; }

inline pair<int, point> getConj (point s1, point e1, point s2, point e2)
{
	LD a = (s2 - s1) * (e1 - s1), b = (e2 - s1) * (e1 - s1);
	if (sgn(a - b) == 0)
		return make_pair(0, point(0.0, 0.0));
	point r = (a * e2 - b * s2) / (a - b);
	if (!onSeg(r, s1, e1) || !onSeg(r, s2, e2)) return make_pair(-1, r); // intersection of the two lines.
	return make_pair(1, r); // intersection of the two segments.
}
inline int colinear (point s1, point e1, point s2, point e2)
{
	LD a = (s2 - s1) * (e1 - s1), b = (e2 - s1) * (e1 - s1);
	if (sgn(a - b) != 0 || sgn(a) != 0) return 0;
	if (onSeg(s2, s1, e1) && onSeg(e2, s1, e1)) return 1;
	if (onSeg(s2, s1, e1) || onSeg(e2, s1, e1)) return 2;
	return 3;
}
//}}}

const int N = 105;

point P[N];
int n;

inline int check (point O, LD r) {
	for (int i = 1; i <= n; ++i)
		if (sgn((P[i] - O).len() - r) < 0) return false;
	return true;
}
inline int check (int i, int j, int k, point O) {
	int a = sgn((O - P[i]) * (P[j] - P[i])), b = sgn((O - P[i]) * (P[k] - P[i]));
	return a && b && (a + b == 0);
}

int main () {
#ifdef LOCAL
	freopen("in", "r", stdin);
#endif
	cin >> n;
	for (int i = 1; i <= n; ++i)
		cin >> P[i];
	LD res = -1.0;
	rep(i, 1, n) rep(j, 1, i - 1) rep(k, 1, j - 1) {
		point S1 = (P[i] + P[j]) / 2.0, E1 = S1 + (P[i] - P[j]).oppo(),
			  S2 = (P[i] + P[k]) / 2.0, E2 = S2 + (P[k] - P[i]).oppo();
		auto r = getConj(S1, E1, S2, E2);
		if (!r.Px) continue;
		if (!(check(i, j, k, r.Py) && check(j, i, k, r.Py) && check(k, i, j, r.Py))) {
			continue;
		}
		LD cr = (r.Py - P[i]).len();
		if (check(r.Py, cr)) res = max(res, cr);
	}
	rep(i, 1, n) rep(j, 1, i - 1) rep(k, 1, j - 1) {
		LD dis[3] = {(P[i] - P[j]).len(), (P[j] - P[k]).len(), (P[i] - P[k]).len()};
		sort(dis, dis + 3);
		if (sgn(dis[0] - dis[1]) || sgn(dis[0] * dis[0] * 2 - dis[2] * dis[2])) continue;
		int bl = -1;
		rep(l, 1, k - 1) {
			int cur = !(sgn((P[l] - P[i]).len() - dis[0])) + !(sgn((P[l] - P[j]).len() - dis[0])) + !(sgn((P[l] - P[k]).len() - dis[0]));
			if (cur == 2) bl = l;
		}
		if (bl == -1) continue;
		point O = (P[i] + P[j] + P[k] + P[bl]) / 4.0;
		LD cr = (P[i] - O).len();
		if (check(O, cr)) res = max(res, cr);
	}
	if (res < 0) puts("-1"); else
		printf("%.8f\n", double(res));
	return 0;
}


#include <iostream>
#include <sstream>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <utility>
#include <cassert>
#include <numeric>
#include <sstream>
using namespace std;

#define REQUIRE(cond, message) \
    do { \
        if (!(cond)) { \
            std::cerr << message << std::endl; \
            assert(false); \
        } \
    } while (false)

#define forn(i, n) for (int i = 0; i < int(n); ++i)
#define for1(i, n) for (int i = 1; i <= int(n); ++i)
#define forv(i, v) forn(i, (v).size())
#define pb push_back
#define mp make_pair
#define all(v) (v).begin(), (v).end()

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef vector<string> vs;
typedef long double ld;
struct Point
{
    ld x, y;
};
const int NMAX = 200;
Point pts[NMAX];
int n;
ld vectProd(const Point& p, const Point& q)
{
    return p.x * q.y - p.y * q.x;
}
const ld EPS = 1e-5;

ld sqr(ld x) { return x * x; }

ld dist2(const Point& p, const Point& q)
{
    return sqr(p.x - q.x) + sqr(p.y - q.y);
}

bool good(const Point& p, ld dst2)
{
    vector<Point> vs;
    forn(i, n) {
        ld cd = dist2(p, pts[i]);
        if (cd < -EPS + dst2) return false;
        if (fabsl(cd - dst2) < EPS) {
            vs.pb(Point());
            vs.back().x = pts[i].x - p.x;
            vs.back().y = pts[i].y - p.y;
        }
    }
    if (vs.size() < 3) return false;
    vector<pair<ld, int> > tmp;
    forv(i, vs) {
        tmp.pb(mp(atan2l(vs[i].y, vs[i].x), i));
    }
    sort(all(tmp));
    forv(i, tmp) {
        int ia;
        if (i == 0) ia = tmp.back().second;
        else ia = tmp[i - 1].second;
        int ib = tmp[i].second;
        if (vectProd(vs[ia], vs[ib]) < EPS) return false;
    }
    return true;
}

ld det(ld a, ld b, ld c, ld d)
{
    return a * d - b * c;
}

void solve()
{
    cin >> n;
    forn(i, n) {
        cin >> pts[i].x >> pts[i].y;
        pts[i].x;
        pts[i].y;
    }
    ld ans = 0;
    forn(i, n) {
        forn(j, i) {
            forn(k, j) {
                Point m1 = {(pts[i].x + pts[j].x) / 2,
                            (pts[i].y + pts[j].y) / 2};
                Point m2 = {(pts[i].x + pts[k].x) / 2,
                            (pts[i].y + pts[k].y) / 2};
                Point v1 = {pts[i].y - pts[j].y, pts[j].x - pts[i].x};
                Point v2 = {pts[i].y - pts[k].y, pts[k].x - pts[i].x};
                if (fabsl(vectProd(v1, v2)) < EPS) continue;
                ld d = det(v1.x, -v2.x, v1.y, -v2.y);
                ld d1 = det(m2.x - m1.x, -v2.x, m2.y-m1.y, -v2.y);
                ld d2 = det(v1.x, m2.x-m1.x, v1.y, m2.y-m1.y);
                ld t1 = d1 / d;
                ld t2 = d2 / d;
                Point p = {m1.x + v1.x * t1, m1.y + v1.y * t1};
                ld dst2 = (p.x-pts[i].x)*(p.x-pts[i].x)
                         +(p.y-pts[i].y)*(p.y-pts[i].y);
                if (good(p, dst2)) {
                    ans = max(ans, sqrtl(dst2));
                }
            }
        }
    }
    if (ans < EPS) cout << -1 << endl;
    else {
        cout.precision(10);
        cout << fixed << ans << endl;
    }
}

int main()
{
    ios_base::sync_with_stdio(false);
    solve();
    return 0;
}


#include <bits/stdc++.h>
#define eps 1e-9
#define ok(i,j,k) ((a[i]-a[j])%(a[k]-a[j])>eps)
using namespace std;

struct point
{
	double x,y;
	point(double _x=0,double _y=0) {x=_x,y=_y;}
	double dis() {return x*x+y*y;}
	friend point operator -(const point&A,const point&B) {return point(A.x-B.x,A.y-B.y);}
	friend double operator *(const point&A,const point&B) {return A.x*B.y-B.x*A.y;}
	friend double operator %(const point&A,const point&B) {return A.x*B.x+A.y*B.y;}
} a[105];
int N;
double ans=-1,d[105][105];

void init()
{
	scanf("%d",&N);
	for (int i=1; i<=N; i++) scanf("%lf%lf",&a[i].x,&a[i].y);
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) d[i][j]=(a[i]-a[j]).dis();
}

void renew(point p,double r)
{
	for (int i=1; i<=N; i++) if ((p-a[i]).dis()-r<-eps) return;
	ans=max(ans,sqrt(r));
}

void doit()
{
	for (int i=1; i<=N; i++)
		for (int j=i+1; j<=N; j++)
			for (int k=j+1; k<=N; k++) if (ok(i,j,k)&&ok(j,k,i)&&ok(k,i,j))
			{
				point A((a[j].x-a[i].x)*2,(a[k].x-a[i].x)*2);
				point B((a[j].y-a[i].y)*2,(a[k].y-a[i].y)*2);
				point C(a[i].dis()-a[j].dis(),a[i].dis()-a[k].dis());
				point P((B*C)/(A*B),(A*C)/(B*A));
				double r=(a[i]-P).dis();
				renew(P,r);
			}
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) if (i!=j)
			for (int k=1; k<=N; k++) if (i!=k&&j!=k)
				for (int l=1; l<=N; l++) if (i!=l&&j!=l&&k!=l&&d[i][j]==d[k][l]&&d[i][l]==d[j][k]&&d[i][k]==d[j][l])
					renew(point((a[i].x+a[k].x)/2,(a[i].y+a[k].y)/2),d[i][k]/4);
	if (ans<0) puts("-1"); else printf("%.9lf\n",ans);
}

int main()
{
	init();
	doit();
	return 0;
}


#include <bits/stdc++.h>
#define eps 1e-7
#define ok(i,j,k) ((a[i]-a[j])%(a[k]-a[j])>eps)
using namespace std;

struct point
{
	double x,y;
	point(double _x=0,double _y=0) {x=_x,y=_y;}
	double dis() {return x*x+y*y;}
	friend point operator -(const point&A,const point&B) {return point(A.x-B.x,A.y-B.y);}
	friend double operator *(const point&A,const point&B) {return A.x*B.y-B.x*A.y;}
	friend double operator %(const point&A,const point&B) {return A.x*B.x+A.y*B.y;}
} a[105];
int N;
double ans=-1,d[105][105];

void init()
{
	scanf("%d",&N);
	for (int i=1; i<=N; i++) scanf("%lf%lf",&a[i].x,&a[i].y);
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) d[i][j]=(a[i]-a[j]).dis();
}

void renew(point p,double r)
{
	for (int i=1; i<=N; i++) if ((p-a[i]).dis()-r<-eps) return;
	ans=max(ans,sqrt(r));
}

void doit()
{
	for (int i=1; i<=N; i++)
		for (int j=i+1; j<=N; j++)
			for (int k=j+1; k<=N; k++) if (ok(i,j,k)&&ok(j,k,i)&&ok(k,i,j))
			{
				point A((a[j].x-a[i].x)*2,(a[k].x-a[i].x)*2);
				point B((a[j].y-a[i].y)*2,(a[k].y-a[i].y)*2);
				point C(a[i].dis()-a[j].dis(),a[i].dis()-a[k].dis());
				point P((B*C)/(A*B),(A*C)/(B*A));
				double r=(a[i]-P).dis();
				renew(P,r);
			}
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) if (i!=j)
			for (int k=1; k<=N; k++) if (i!=k&&j!=k)
				for (int l=1; l<=N; l++) if (i!=l&&j!=l&&k!=l&&d[i][j]==d[k][l]&&d[i][l]==d[j][k]&&d[i][k]==d[j][l])
					renew(point((a[i].x+a[k].x)/2,(a[i].y+a[k].y)/2),d[i][k]/4);
	if (ans<0) puts("-1"); else printf("%.9lf\n",ans);
}

int main()
{
	init();
	doit();
	return 0;
}


#include <bits/stdc++.h>
#define eps 1e-9
#define ok(i,j,k) ((a[i]-a[j])%(a[k]-a[j])>eps)
using namespace std;

struct point
{
	double x,y;
	point(double _x=0,double _y=0) {x=_x,y=_y;}
	double dis() {return x*x+y*y;}
	friend point operator -(const point&A,const point&B) {return point(A.x-B.x,A.y-B.y);}
	friend double operator *(const point&A,const point&B) {return A.x*B.y-B.x*A.y;}
	friend double operator %(const point&A,const point&B) {return A.x*B.x+A.y*B.y;}
} a[105];
int N;
double ans=-1,d[105][105];

void init()
{
	scanf("%d",&N);
	for (int i=1; i<=N; i++) scanf("%lf%lf",&a[i].x,&a[i].y);
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) d[i][j]=(a[i]-a[j]).dis();
}

void renew(point p,double r)
{
	for (int i=1; i<=N; i++) if ((p-a[i]).dis()-r<-eps) return;
	ans=max(ans,sqrt(r));
}

void doit()
{
	for (int i=1; i<=N; i++)
		for (int j=i+1; j<=N; j++)
			for (int k=j+1; k<=N; k++) if (ok(i,j,k)&&ok(i,k,j)&&ok(j,k,i))
			{
				point A((a[j].x-a[i].x)*2,(a[k].x-a[i].x)*2);
				point B((a[j].y-a[i].y)*2,(a[k].y-a[i].y)*2);
				point C(a[i].dis()-a[j].dis(),a[i].dis()-a[k].dis());
				point P((B*C)/(A*B),(A*C)/(B*A));
				double r=(a[i]-P).dis();
				renew(P,r);
			}
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) if (i!=j)
			for (int k=1; k<=N; k++) if (i!=k&&j!=k)
				for (int l=1; l<=N; l++) if (i!=l&&j!=l&&k!=l&&d[i][j]==d[k][l]&&d[i][l]==d[j][k]&&d[i][k]==d[j][l])
					renew(point((a[i].x+a[k].x)/2,(a[i].y+a[k].y)/2),d[i][k]/2);
	if (ans<0) puts("-1"); else printf("%.9lf\n",ans);
}

int main()
{
	init();
	doit();
	return 0;
}


#include <bits/stdc++.h>
#define eps 1e-9
#define ok(i,j,k) ((a[i]-a[j])%(a[k]-a[j])>eps)
using namespace std;

struct point
{
	double x,y;
	point(double _x=0,double _y=0) {x=_x,y=_y;}
	double dis() {return x*x+y*y;}
	friend point operator -(const point&A,const point&B) {return point(A.x-B.x,A.y-B.y);}
	friend double operator *(const point&A,const point&B) {return A.x*B.y-B.x*A.y;}
	friend double operator %(const point&A,const point&B) {return A.x*B.x+A.y*B.y;}
} a[105];
int N;
double ans=-1,d[105][105];

void init()
{
	scanf("%d",&N);
	for (int i=1; i<=N; i++) scanf("%lf%lf",&a[i].x,&a[i].y);
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) d[i][j]=(a[i]-a[j]).dis();
}

void renew(point p,double r)
{
	for (int i=1; i<=N; i++) if ((p-a[i]).dis()-r<-eps) return;
	ans=max(ans,sqrt(r));
}

void doit()
{
	for (int i=1; i<=N; i++)
		for (int j=i+1; j<=N; j++)
			for (int k=j+1; k<=N; k++) if (ok(i,j,k)&&ok(j,k,i)&&ok(k,i,j))
			{
				point A((a[j].x-a[i].x)*2,(a[k].x-a[i].x)*2);
				point B((a[j].y-a[i].y)*2,(a[k].y-a[i].y)*2);
				point C(a[i].dis()-a[j].dis(),a[i].dis()-a[k].dis());
				point P((B*C)/(A*B),(A*C)/(B*A));
				double r=(a[i]-P).dis();
				renew(P,r);
			}
	for (int i=1; i<=N; i++)
		for (int j=1; j<=N; j++) if (i!=j)
			for (int k=1; k<=N; k++) if (i!=k&&j!=k)
				for (int l=1; l<=N; l++) if (i!=l&&j!=l&&k!=l&&d[i][j]==d[k][l]&&d[i][l]==d[j][k]&&d[i][k]==d[j][l])
					renew(point((a[i].x+a[k].x)/2,(a[i].y+a[k].y)/2),d[i][k]/2);
	if (ans<0) puts("-1"); else printf("%.9lf\n",ans);
}

int main()
{
	init();
	doit();
	return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

int K[100];
Point xy[100];

Point circumcircle(int i, int j, int k) {
    Point A = xy[i], B = xy[j], C = xy[k];
    double x = K[i]*(B.y-C.y)+K[j]*(C.y-A.y)+K[k]*(A.y-B.y);
    double y = K[i]*(C.x-B.x)+K[j]*(A.x-C.x)+K[k]*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x-p3.x)*(p2.y-p3.y)-(p2.x-p3.x)*(p1.y-p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    REP(i, N) {
        K[i] = xy[i].x*xy[i].x+xy[i].y*xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        REP(j, i) {
            REP(k, j) {
                Point c = circumcircle(i, j, k);
                bool in = inside(xy[i], xy[j], xy[k], c) && abs(c.x) < 1e4 && abs(c.y) < 1e4;

                // check if there is another point strictly inside the circumference
                bool ok = true;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok && in) {
                    // no point strictly inside
                    maxDist = max(maxDist, dist(xy[i], c));
                } else if(ok && !in) {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (dist(median(pts[kk], pts[(kk+1)%3]), c) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(dist(xy[i], c)-dist(c, xy[kk])) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circumcisrcle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x-p3.x)*(p2.y-p3.y)-(p2.x-p3.x)*(p1.y-p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        REP(j, i) {
            REP(k, j) {
                Point c = circumcisrcle(xy[i], xy[j], xy[k]);
                bool in = inside(xy[i], xy[j], xy[k], c) && abs(c.x) < 1e4 && abs(c.y) < 1e4;

                // check if there is another point strictly inside the circumference
                bool ok = true;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok && in) {
                    // no point strictly inside
                    maxDist = max(maxDist, dist(xy[i], c));
                } else if(ok && !in) {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c) && abs(c.x) < 1e4 && abs(c.y) < 1e4;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    bool b1, b2, b3;
    b1 = sign(p, v1, v2) < 0;
    b2 = sign(p, v2, v3) < 0;
    b3 = sign(p, v3, v1) < 0;

    return ((b1 == b2) && (b2 == b3));
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c);
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false; int midIdx = -1;
                    REP(kk, 3) {
                        mid |= sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS;
                        if(mid)
                            midIdx == kk;
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                if(sign(pts[midIdx], pts[(midIdx+1)%3], pts[(midIdx+2)%3])*sign(pts[midIdx], pts[(midIdx+1)%3], xy[kk]) <= 0) {
                                    maxDist = max(maxDist, dist(xy[i], c));
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c) && abs(c.x) > 1e4 && abs(c.y) > 1e4;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c);
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false; int midIdx = -1;
                    REP(kk, 3) {
                        mid |= sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS;
                        if(mid)
                            midIdx == kk;
                    }
                    if(mid)
                        maxDist = max(maxDist, dist(xy[i], c));
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c);
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false; int midIdx = -1;
                    REP(kk, 3) {
                        mid |= sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS;
                        if(mid)
                            midIdx == kk;
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                    maxDist = max(maxDist, dist(xy[i], c));
                                    break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

int K[100];
Point xy[100];

Point circumcircle(int i, int j, int k) {
    Point A = xy[i], B = xy[j], C = xy[k];
    double x = K[i]*(B.y-C.y)+K[j]*(C.y-A.y)+K[k]*(A.y-B.y);
    double y = K[i]*(C.x-B.x)+K[j]*(A.x-C.x)+K[k]*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x-p3.x)*(p2.y-p3.y)-(p2.x-p3.x)*(p1.y-p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    double d1 = (A.x-B.x), d2 = (A.y-B.y);
    return d1*d1+d2*d2;
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    REP(i, N) {
        K[i] = xy[i].x*xy[i].x+xy[i].y*xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        REP(j, N) {
            if(i == j) continue;
            // partition the points to the left and right
            Point cc;
            double rad = INF;
            REP(k, N) {
                if(k != i && k != j) {
                    Point c = circumcircle(i, j, k);
                    double s1 = sign(xy[i], xy[j], xy[k]), s2 = sign(xy[i], xy[j], c);
                    // center and point are on one side, the circumcenter is inside
                    if(inside(xy[i], xy[j], xy[k], c) && (s1 > EPS && s2 > EPS)) {
                        if(rad > dist(c, xy[i])) {
                            rad = min(dist(c, xy[i]), rad);
                            cc = c;
                        }
                    }
                }
            }

            // check that there are no other points strictly inside
            bool ok = true;
            REP(kk, N) {
                if(kk != i && kk != j && rad > dist(cc, xy[kk])) {
                    ok = false;
                    break;
                }
            }

            if(ok && rad != INF) {
                maxDist = max(maxDist, rad);
            }

            // check the middle of the points
            ok = true;
            int count = 0;
            Point mid = median(xy[i], xy[j]);
            REP(k, N) {
                if(k != i && k != j) {
                    if(dist(xy[i], mid) > dist(xy[k], mid)) {
                        ok = false;
                        break;
                    } else if(abs(dist(xy[i], mid)-dist(xy[k], mid)) < EPS)
                        count++;
                }
            }

            if(ok && count >= 2) {
                maxDist = max(maxDist, dist(mid, xy[i]));
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point circle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    vector<Point> xy(N);
    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
        if(N == 100)
            cout << xy[i].x << " " << xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        FOR(j, i+1, N-1) {
            FOR(k, j+1, N-1) {
                Point c = circle(xy[i], xy[j], xy[k]);
                bool ok = inside(xy[i], xy[j], xy[k], c);
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok) {
                    maxDist = max(maxDist, dist(xy[i], c));
                } else {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false; int midIdx = -1;
                    REP(kk, 3) {
                        mid |= sqrt(dist(median(pts[kk], pts[(kk+1)%3]), c)) < EPS;
                        if(mid)
                            midIdx == kk;
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(sqrt(dist(xy[i], c))-sqrt(dist(c, xy[kk]))) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

Point xy[100];

Point circumcircle(Point &A, Point &B, Point &C) {
    double x = (A.x*A.x+A.y*A.y)*(B.y-C.y)+(B.x*B.x+B.y*B.y)*(C.y-A.y)+(C.x*C.x+C.y*C.y)*(A.y-B.y);
    double y = (A.x*A.x+A.y*A.y)*(C.x-B.x)+(B.x*B.x+B.y*B.y)*(A.x-C.x)+(C.x*C.x+C.y*C.y)*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x-p3.x)*(p2.y-p3.y)-(p2.x-p3.x)*(p1.y-p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        REP(j, i) {
            REP(k, j) {
                Point c = circumcircle(xy[i], xy[j], xy[k]);
                bool in = inside(xy[i], xy[j], xy[k], c) && abs(c.x) < 1e4 && abs(c.y) < 1e4;

                // check if there is another point strictly inside the circumference
                bool ok = true;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok && in) {
                    // no point strictly inside
                    maxDist = max(maxDist, dist(xy[i], c));
                } else if(ok && !in) {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (dist(median(pts[kk], pts[(kk+1)%3]), c) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(dist(xy[i], c)-dist(c, xy[kk])) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}


#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

#define LL long long
#define F first
#define S second
#define PB push_back
#define PF push front
#define MP make_pair
#define REP(x, n) for(int x=0; x<(n); ++x)
#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define FORD(x, b, e) for(int x=b; x>=(e); x)
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define MOD(x, n) ((x)%(n)+(n))%(n)
#define SZ(x) (int((x).size()))
#define ALL(x) ((x).begin()),((x).end())
#define SORT(v) sort((v).begin(),(v).end())
#define UNIQUE(v) SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
LL GCD( LL a , LL b ) { while( b ) b ^= a ^= b ^= a %= b ; return a ; }
LL LCM( LL a , LL b ) { return a * ( b / GCD( a , b ) ) ; }

typedef vector<int>    VI;
typedef vector<VI>     VVI;
typedef vector<LL>     VLL;
typedef vector<bool>   VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII>    VPII;
typedef pair<LL, LL>   PLL;
typedef vector<PLL>    VPLL;

const double EPS = 10e-7;
const double INF = (1LL << 62);

struct Point {
    double x;
    double y;
};

int K[100];
Point xy[100];

Point circumcircle(int i, int j, int k) {
    Point A = xy[i], B = xy[j], C = xy[k];
    double x = K[i]*(B.y-C.y)+K[j]*(C.y-A.y)+K[k]*(A.y-B.y);
    double y = K[i]*(C.x-B.x)+K[j]*(A.x-C.x)+K[k]*(B.x-A.x);
    double d = 2.0*(A.x*(B.y-C.y)+B.x*(C.y-A.y)+C.x*(A.y-B.y));
    x /= d; y /= d;

    Point p; p.x = x; p.y = y;
    return p;
}

double sign(Point &p1, Point &p2, Point &p3) {
    return (p1.x-p3.x)*(p2.y-p3.y)-(p2.x-p3.x)*(p1.y-p3.y);
}

bool inside(Point &v1, Point &v2, Point &v3, Point &p) {
    double s1, s2, s3;
    s1 = sign(p, v1, v2);
    s2 = sign(p, v2, v3);
    s3 = sign(p, v3, v1);

    return (s1 > EPS && s2 > EPS && s3 > EPS) || (s1 < -EPS && s2 < -EPS && s3 < -EPS);
}

double dist(Point A, Point B) {
    double d1 = (A.x-B.x), d2 = (A.y-B.y);
    return d1*d1+d2*d2;
}

Point median(Point A, Point B) {
    Point m;
    m.x = (A.x+B.x)/2;
    m.y = (A.y+B.y)/2;
    return m;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int N;
    cin >> N;

    REP(i, N) {
        cin >> xy[i].x >> xy[i].y;
    }

    REP(i, N) {
        K[i] = xy[i].x*xy[i].x+xy[i].y*xy[i].y;
    }

    double maxDist = -1;
    REP(i, N) {
        REP(j, i) {
            REP(k, j) {
                Point c = circumcircle(i, j, k);
                bool in = inside(xy[i], xy[j], xy[k], c) && abs(c.x) < 1e4 && abs(c.y) < 1e4;

                // check if there is another point strictly inside the circumference
                bool ok = true;
                REP(kk, N) {
                    if(kk != i && kk != j && kk != k && dist(xy[i], c) > dist(c, xy[kk])) {
                        ok = false;
                        break;
                    }
                }
                if(ok && in) {
                    // no point strictly inside
                    maxDist = max(maxDist, dist(xy[i], c));
                } else if(ok && !in) {
                    Point pts[3] = {xy[i], xy[j], xy[k]};
                    bool mid = false;
                    REP(kk, 3) {
                        mid |= (dist(median(pts[kk], pts[(kk+1)%3]), c) < EPS);
                    }

                    if(mid) {
                        REP(kk, N) {
                            if(kk != i && kk != j && kk != k && abs(dist(xy[i], c)-dist(c, xy[kk])) < EPS) {
                                maxDist = max(maxDist, dist(xy[i], c));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    if(maxDist != -1)
        cout << sqrt(maxDist) << endl;
    else
        cout << -1 << endl;

    return 0;
}