#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-8){
    //     return -1;
    // }
    // auto z = (abs(a) * abs(a) * b - abs(b) * abs(b) * a) / c;
    // const double radius = abs(z);
    // z += p1.to_complex();
    // const Point<double> center(z.real(), z.imag());
    const auto sub12 = p1 - p2;
    const auto sub23 = p2 - p3;
    const ll a = sub12.x;
    const ll b = sub12.y;
    const ll c = sub23.x;
    const ll d = sub23.y;
    if(sub12.cross(sub23) == 0){
        return -1;
    }
    const double d12 = p1.norm2() - p2.norm2();
    const double d23 = p2.norm2() - p3.norm2();
    Point<double> center(
        (d * d12 - b * d23) / (2 * sub12.cross(sub23)),
        (- c * d12 + a * d23) / (2 * sub12.cross(sub23))
    );
    const double radius = dist(center, p1);

    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: 256