#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i,n) for (ll i = 0; i < (n); ++i)


template<typename T>
struct Point {
    T x, y;
    Point() : x(0), y(0) {}
    Point(T x, T y) : x(x), y(y) {}

    int quadrant() const {
        if(x == 0 && y == 0){
            return 0;
        }
        if(x >= 0){
            if(y >= 0){
                return 1;
            }else{
                return 4;
            }
        }else{
            if(y >= 0){
                return 2;
            }else{
                return 3;
            }
        }
    }

    Point& operator+=(const Point& other){
        x += other.x;
        y += other.y;
        return *this;
    }

    Point& operator-=(const Point& other){
        x -= other.x;
        y -= other.y;
        return *this;
    }

    Point operator+(const Point& other) const {
        return Point(x, y) += other;
    }
    Point operator-(const Point& other) const{
        return Point(x, y) -= other;
    }

    T cross(const Point& q) const {
        return x * q.y - y * q.x;
    }

    bool operator<(const Point& q) const {
        int qp = quadrant();
        int qq = q.quadrant();
        if(qp != qq){ return qp < qq; }
        return cross(q) > 0;
    }

    bool operator<=(const Point& q) const {
        int qp = quadrant();
        int qq = q.quadrant();
        if(qp != qq){ return qp < qq; }
        return cross(q) >= 0;
    }

    T dot(const Point& q) const {
        return x * q.x + y * q.y;
    }

    T norm2() const {
        return x * x + y * y;
    }

    double norm() const {
        return sqrt((double)norm2());
    }

    double dist(const Point& q) const {
        return (*this - q).norm();
    }

    complex<T> to_complex() const {
        return complex<T>(x, y);
    }
};

template<typename T>
bool cmp_xy(const Point<T>& p, const Point<T>& q){
    if(p.x != q.x){
        return p.x < q.x;
    }else{
        return p.y < q.y;
    }
}

template<typename T>
double dist(const Point<T>& p, const Point<T>& q){
    return p.dist(q);
}


double norm(double x, double y){
    return sqrt(x * x + y * y);
}

bool is_enclose(const vector<Point<double>>& ps, const Point<double>& center, double r, double eps=1e-6){
    for(const auto q : ps){
        if(dist(q, center) > r + eps){ return false; }
    }
    return true;
}

double check(const vector<Point<double>>& ps, const Point<double>& p1, const Point<double>& p2){
    Point<double> center((p1.x + p2.x) / 2.0, (p1.y + p2.y) / 2.0);
    const double radius = dist(p1, center);

    if(is_enclose(ps, center, radius)){
        return radius;
    }else{
        return -1;
    }
}

double check(
        const vector<Point<double>>& ps,
        const Point<double>& p1, const Point<double>& p2, const Point<double>& p3
){
    const auto a = (p2 - p1).to_complex();
    const auto b = (p3 - p1).to_complex();
    const auto c = a * conj(b) - conj(a) * b;
    if(abs(c) <= 1e-10){
        return -1;
    }
    auto z = a * b * conj(b - a) / c;
    const double radius = abs(z);
    z += p1.to_complex();
    const Point<double> center(z.real(), z.imag());

    if(is_enclose(ps, center, radius)){
        return radius;
    }else{
        return -1;
    }
}

void solve(long long N, std::vector<long long> x, std::vector<long long> y){
    vector<Point<double>> p(N);
    REP(i, N){
        p.at(i).x = x.at(i);
        p.at(i).y = y.at(i);
    }

    double ans = -1;
    for(ll i = 0; i < N; ++i){
        for(ll j = i + 1; j < N; ++j){
            const double tmp = check(p, p.at(i), p.at(j));
            if(tmp > 0 && (ans < 0 || ans > tmp)){
                ans = tmp;
            }

            for(ll k = j + 1; k < N; ++k){
                const double tmp = check(p, p.at(i), p.at(j), p.at(k));
                if(tmp > 0 && (ans < 0 || ans > tmp)){
                    ans = tmp;
                }
            }
        }
    }
    printf("%.20f\n", ans);
}

// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
int main(){
    long long N;
    scanf("%lld",&N);
    std::vector<long long> x(N);
    std::vector<long long> y(N);
    for(int i = 0 ; i < N ; i++){
        scanf("%lld",&x[i]);
        scanf("%lld",&y[i]);
    }
    solve(N, std::move(x), std::move(y));
    return 0;
}


Measured memory_bytes: 512