#include <stdio.h>
#include <stdlib.h>

#include <iostream>
#include <iomanip>
#include <sstream>
#include <stdint.h>
#include <string.h>

#define _USE_MATH_DEFINES
#include <math.h>

#include <vector>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <deque>
#include <string>

#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
#include <random>

#define sqr(x) (x) * (x)

typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;

using namespace std;
using namespace std::chrono;

const i64 mod = 1000000007ll;
const i64 smod = 998244353ll;
const i64 inf = 10000000000000007ll;
const long double dinf = 1e6;

const long double eps = 1e-8;

struct less_key {
    bool operator()(const std::pair<i64,i64> &left, const std::pair<i64,i64> &right) {
        return left.first < right.first;
    }
};

i64 gcd (i64 a, i64 b, i64 & x, i64 & y) {
    if (a == 0) {
        x = 0;
        y = 1;
        return b;
    }
    i64 x1, y1;
    i64 d = gcd (b % a, a, x1, y1);
    x = y1 - (b / a) * x1;
    y = x1;
    return d;
}

i64 rev(i64 a, i64 m) {
    i64 x, y;
    i64 g = gcd(a, m, x, y);
    if (g != 1) {
        throw g;
    }
    return (x % m + m) % m;
}

i64 binpow(i64 a, i64 p) {
    if (p == 0) {
        return 1;
    }
    if (p == 1) {
        return a;
    }
    i64 t = binpow(a, p / 2);
    t *= t;
    t %= mod;

    if (p % 2) {
        t *= a;
        t %= mod;
    }

    return t;
}

const i64 MAXN = 52;

i64 n;
pair<long double, long double> a[MAXN];

pair<long double, long double> c[MAXN][MAXN];
pair<long double, long double> v[MAXN][MAXN];


long double dist(pair<long double, long double> p1, pair<long double, long double> p2) {
    return sqrt(sqr(p1.first - p2.first) + sqr(p1.second - p2.second));
}

long double dist(i64 i, i64 j) {
    return dist(a[i], a[j]);
}

pair<long double, long double> getp(i64 i, i64 j, long double k, long double t) {
    pair<long double, long double> p = {c[i][j].first + v[i][j].first * k * t, c[i][j].second + v[i][j].second * k * t};
    return p;
}

long double getr(i64 i, i64 j, long double k, long double t) {
    auto p = getp(i, j, k, t);

    long double r1 = dist(a[i], p);
    long double r2 = dist(a[j], p);

    long double d = r1 - r2;
    if (abs(d) > eps) {
        throw d;
    }

    return (r1 + r2) / 2.0;
}

bool check(i64 i, i64 j, long double k, long double t) {
    auto p = getp(i, j, k, t);
    long double r = getr(i, j, k, t);

    for (i64 k = 0; k < n; k++) {
        if (k == i || k == j) {
            continue;
        }
        if (dist(p, a[k]) > r + eps) {
            return false;
        }
    }

    return true;
}

long double bin(i64 i, i64 j, long double k, long double l, long double r) {
    while(1) {
        long double t = (l + r) / 2.0;
        if (getr(i, j, k, r) - getr(i, j, k, l) < eps) {
//            cerr << t << endl;
            return getr(i, j, k, t);
        }

        if (check(i, j, k, t)) {
            r = t;
        } else {
            l = t;
        }
    }
}

bool check(long double r, pair<long double, long double> c) {
    for (i64 i = 0; i < n; i++) {
        if (dist(a[i], c) > r + eps) {
            return false;
        }
    }

    return true;
}

bool check(long double r) {
    for (i64 i = 0; i < n; i++) {
        for (i64 j = 0; j < n; j++) {
            if (i == j) {
                continue;
            }
            long double d = dist(a[i], a[j]) / 2.0;
            if (r < d) {
                continue;
            }
            long double t = sqrt(sqr(r) - sqr(d));

            auto pp = getp(i, j, 1.0, t);
            auto pr = getr(i, j, 1.0, t);

            auto mp = getp(i, j, -1.0, t);
            auto mr = getr(i, j, -1.0, t);

//            if (abs(pr - r) > eps) {
//                throw abs(pr - r);
//            }
//
//            if (abs(mr - r) > eps) {
//                throw abs(mr - r);
//            }

            if (check(pr, pp)) {
                return true;
            }

            if (check(mr, mp)) {
                return true;
            }
        }
    }

    return false;
}

long double bin(long double l, long double r) {
    while(1) {
        long double t = (l + r) / 2.0;
        if (r - l < eps) {
            return t;
        }

        if (check(t)) {
            r = t;
        } else {
            l = t;
        }
    }

}

int main() {
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout.precision(15); cout.setf(ios::fixed);

    cerr << dist({0, 0}, {3, 7.0 / 8}) << endl;

    cin >> n;
    for (i64 i = 0; i < n; i++) {
        cin >> a[i].first >> a[i].second;
    }

    for (i64 i = 0; i < n; i++) {
        for (i64 j = 0; j < n; j++) {
            if (i == j) {
                continue;
            }
            c[i][j] = {(a[i].first + a[j].first) / 2.0, (a[i].second + a[j].second) / 2.0};
            v[i][j] = {a[j].second - a[i].second, a[i].first - a[j].first};

            long double d = sqrt(sqr(v[i][j].first) + sqr(v[i][j].second));
            v[i][j].first /= d;
            v[i][j].second /= d;
        };
    }

    long double R = bin(0, dinf);

//    for (i64 i = 0; i < n; i++) {
//        for (i64 j = 0; j < n; j++) {
//            if (i == j) {
//                continue;
//            }
//
//            long double pr = bin(i, j, 1.0, 0.0, dinf);
//            R = min(R, pr);
//
//            long double mr = bin(i, j, -1.0, 0.0, dinf);
//            R = min(R, mr);
//        }
//    }

    cout << R << endl;

    return 0;
}


Measured memory_bytes: 384