#include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>

#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
    os << "{";
    for (auto it = v.begin(); it != v.end(); ++it) {
        if (it != v.begin())
            os << ",";
        os << *it;
    }
    return os << "}";
}

template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& v)
{
    os << "{";
    os << v.first << ", " << v.second;
    return os << "}";
}

// ---------------------------------------------------------------------------

using point = complex<double>;
using ll = long long;

//// 内積 (dot product) : a・b = |a||b|cosΘ
//double dot(point a, point b)
//{
//    return real(conj(a) * b);
//}
//
//// 外積 (cross product) : |a×b| = |a||b|sinΘ
//double cross(point a, point b)
//{
//    return imag(conj(a) * b);
//}
//
//// 点の進行方向
//int ccw(point a, point b, point c)
//{
//    b -= a;
//    c -= a;
//    if (cross(b, c) > 0)
//        return +1; // counter clockwise
//    if (cross(b, c) < 0)
//        return -1; // clockwise
//    if (dot(b, c) < 0)
//        return +2; // c -- a -- b
//    if (norm(b) < norm(c))
//        return -2; // a -- b -- c
//    return 0;
//}
//
//
//int my_main(int argc, char** argv)
//{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
//
//    int n;
//    cin >> n;
//    vector<double> x(n);
//    vector<double> y(n);
//
//    for (int i = 0; i < n; i++) {
//        cin >> x[i] >> y[i];
//    }
//
//    if (n == 2) {
//        cout << fixed << setprecision(10);
//        cout << hypot(x[0] - x[1], y[0] - y[1]) / 2 << endl;
//        return 0;
//    }
//
//    double rr = 10000000000000;
//    for (int i = 0; i < n; i++) {
//        for (int j = i + 1; j < n; j++) {
//            for (int k = j + 1; k < n; k++) {
//
//                double a = x[i];
//                double b = y[i];
//                double c = x[j];
//                double d = y[j];
//                double e = x[k];
//                double f = y[k];
//                double aa = a * a;
//                double bb = b * b;
//                double cc = c * c;
//                double dd = d * d;
//                double ee = e * e;
//                double ff = f * f;
//                double py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) / (2 * (e - a) * (b - d) - 2 * (c - a) * (b - f));
//
//                double px = 0;
//                if (c == a) {
//                    px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a));
//                } else {
//                    px = (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a));
//                }
//                double r = hypot(px - a, py - b);
//
//                bool ok = true;
//                for (int b = 0; b < n; b++) {
//                    ok &= (hypot(px - x[b], py - y[b])) <= r + 1e-7;
//                }
//                if (ok)
//                    rr = min(rr, r);
//
//                for (int p = 0; p < 3; p++) {
//                    double lx = x[p];
//                    double ly = y[p];
//                    double rx = x[(p + 1) % 3];
//                    double ry = y[(p + 1) % 3];
//
//                    double px = (lx + rx) / 2;
//                    double py = (ly + ry) / 2;
//                    double r = hypot(lx - px, ly - py);
//                    bool ok = true;
//                    for (int b = 0; b < n; b++) {
//                        ok &= (hypot(px - x[b], py - y[b])) <= r + 1e-7;
//                    }
//                    if (ok)
//                        rr = min(rr, r);
//                }
//
//            }
//        }
//    }
//    cout << fixed << setprecision(10);
//    cout << rr << endl;
//    return 0;
//}

int my_main(int argc, char** argv)
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;

    vector<point> p(n);

    for (int i = 0; i < n; i++) {
        double x, y;
        cin >> x >> y;
        p[i] = { x, y };
    }

    double lr = 0;
    double rr = 100000;

    const double EPS = 1e-9;
    for (int bin = 0; bin < 100; bin++) {
        dump(lr);
        dump(rr);
        double mr = (lr + rr) / 2;
        double ok = false;
        for (int j = 0; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                point p1 = p[j];
                point p2 = p[k];

                double distance_of_2circles_2 = abs(p1 - p2) / 2;

                if (distance_of_2circles_2 > mr) {
                    continue;
                }

                double h = sqrt(mr * mr - distance_of_2circles_2 * distance_of_2circles_2);
                auto midpoint = (p1 + p2) / 2.0;

                auto vec = (p2 - p1);
                vec /= abs(vec);

                point vec2(-vec.imag(), vec.real());
                vector<point> cands = {
                    midpoint + vec2 * h,
                    midpoint + vec2 * -h
                };

                for (point c : cands) {
                    dump(c);
                    bool yes = true;
                    for (point pk : p) {
                        yes &= abs(c - pk) <= mr + EPS;
                    }
                    if (yes)
                        ok = true;
                }
            }
        }
        if (ok)
            rr = mr;
        else
            lr = mr;
    }

    cout << fixed << setprecision(10);
    cout << rr << endl;
    return 0;
}


// ----------------------------------------------------------------------------
// Test driver

#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif

#ifdef MAY_RUN_TESTCASE
#include <fstream>

#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif

bool test_file_exists(const std::string& str)
{
    std::ifstream fs(str);
    return fs.is_open();
}

#endif

int main(int argc, char** argv)
{
#ifndef MAY_RUN_TESTCASE
    return my_main(argc, argv);
#else
    if (argc == 1) {
        return my_main(argc, argv);
    } else if (argc == 2) {

        char* stdin_file = argv[1];
        freopen(stdin_file, "r", stdin);
        return my_main(argc, argv);

    } else if (argc == 5) {

        std::string stdin_file = argv[1];
        std::string expected_file = argv[2];
        std::string stdout_file = argv[3];
        std::string stderr_file = argv[4];

        if (!test_file_exists(stdin_file)) {
            std::cerr << stdin_file << " not found" << std::endl;
            return 3;
        }

        if (!test_file_exists(expected_file)) {
            std::cerr << expected_file << " not found" << std::endl;
            return 3;
        }

        int original_stdin = dup(fileno(stdin));
        int original_stdout = dup(fileno(stdout));
        int original_stderr = dup(fileno(stderr));

        freopen(stdin_file.c_str(), "r", stdin);
        freopen(stdout_file.c_str(), "w", stdout);
        freopen(stderr_file.c_str(), "w", stderr);

        int ret = my_main(argc, argv);

        fflush(stdout);
        fflush(stderr);

        dup2(original_stderr, fileno(stderr));
        dup2(original_stdout, fileno(stdout));
        dup2(original_stdin, fileno(stdin));

        if (ret != 0) {
            std::cerr << "main returns " << ret << std::endl;
            return ret;
        }

        std::ifstream inp(stdin_file);
        std::ifstream out(stdout_file);
        std::ifstream err(stderr_file);
        std::ifstream exp(expected_file);

        // Clear is needed if the file is empty.
        std::cout << "----- input -----" << std::endl;
        std::cout << inp.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "----- output ----" << std::endl;
        std::cout << out.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "---- expected ---" << std::endl;
        std::cout << exp.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "----- stderr ----" << std::endl;
        std::cout << err.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl;

        inp.seekg(0);
        out.seekg(0);
        exp.seekg(0);
        err.seekg(0);

        std::string output_str, expected_str;
        {
            std::stringstream output_ss;
            output_ss << out.rdbuf();
            output_str = output_ss.str();

            std::stringstream expected_ss;
            expected_ss << exp.rdbuf();
            expected_str = expected_ss.str();
        }

        // Remove trailing spaces
        output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
        expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);

        if (output_str == expected_str)
            return 0;
        else
            return 1;
    }
    return 1;
#endif
}


Measured memory_bytes: 256