#include <bits/stdc++.h>


using namespace std;

#define lll __int128_t
#define ll __int128_t
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for(int i = 0; i < n; i += 1)

const ll inf = 1e18;
mt19937 rnd(234);
const flt eps = 1e-7;


struct vec {
    ll x, y;

    vec() : x(0), y(0) {}
    vec(ll x, ll y) : x(x), y(y) {}

    ll len2() const {
        return x * x + y * y;
    }


    flt len() const {
        return sqrt((flt)len2());
    }


    vec rotate90() {
        return vec(-y, x);
    }
};


vec operator+(const vec& a, const vec& b) {
    return vec(a.x + b.x, a.y + b.y);
}

vec operator-(const vec& a, const vec& b) {
    return vec(a.x - b.x, a.y - b.y);
}


vec operator/(const vec& a, ll k) {
    return vec(a.x / k, a.y / k);
}


vec operator*(const vec& a, ll k) {
    return vec(a.x * k, a.y * k);
}


ll operator*(const vec& a, const vec& b) {
    return a.x * b.x + a.y * b.y;
}


ll operator%(const vec& a, const vec& b) {
    return a.x * b.y - a.y * b.x;
}


int get_type(const vec& a) {
    if (a.x == 0 and a.y == 0) {
        return 0;
    }
    if (a.x > 0) {
        return 1;
    }
    if (a.x < 0) {
        return 3;
    }
    if (a.y > 0) {
        return 2;
    }
    if (a.y < 0) {
        return 4;
    }
    assert(0);
}


bool operator<(const vec& a, const vec& b) {
    int ta = get_type(a);
    int tb = get_type(b);
    if (ta != tb) {
        return ta < tb;
    }
    return a % b > 0;
}


ll div_ceil(ll a, ll b) {
    if (a >= 0) {
        return (a + b - 1) / b;
    }
    return a / b;
}


struct line {
    vec a;
    ll c;

    line() {}
    line(ll a, ll b, ll c) : a(a, b), c(c) {}
    line(const vec& a, ll c) : a(a), c(c) {}
    line(const vec& p, const vec& q) {
        assert((p - q).len2() > eps);
        a = (p - q).rotate90();
        c = a * p;
    }


    ll get(const vec& p) {
        return a * p - c;
    }

    bool strict_contains(const array<ll, 3>& p) {
        auto [x, y, z] = p;
        ll val = x * a.x + y * a.y;
        // now we need to check that val / z - c > 0 <=>
        // <=> val / z > c <=> ceil(val / z) > c
        return div_ceil(val, z) > c;
    }

    flt normc() {
        return (flt)c / a.len();
    }
};


bool operator<(const line& a, const line& b) {
    return a.a < b.a;
}


array<ll, 3> intersect(const line& s, const line& t) {
    array<ll, 3> p;
    p[2] = s.a.x * t.a.y - s.a.y * t.a.x;
    assert(p[2] != 0);
    p[0] = s.c * t.a.y - s.a.y * t.c;
    p[1] = s.a.x * t.c - s.c * t.a.x;
    if (p[2] < 0) {
        p[0] *= -1;
        p[1] *= -1;
        p[2] *= -1;
    }
    return p;
}


namespace opt {
    flt opt_r = 1e20;

    char opt_type = '0';

    line ln;

    array<ll, 3> cc;
    flt cr;

    void opt_circle(const array<ll, 3>& mcc, flt mcr, flt r) {
        if (r < opt_r) {
            opt_r = r;
            opt_type = 'C';
            cc = mcc;
            cr = mcr;
        }
    }


    void opt_line(const line& mln, flt r) {
        if (r < opt_r) {
            opt_r = r;
            opt_type = 'L';
            ln = mln;
        }
    }


    void print() {
        cout << fixed << setprecision(20);
        if (opt_type == 'C') {
            cout << opt_r << "\n";
            cout << 'C' << " " << (long long)cc[0] << " " << (long long)cc[1] << " " << (long long)cc[2] << " " << cr << "\n";
            return;
        }
        if (opt_type == 'L') {
            cout << opt_r << "\n";
            cout << 'L' << " " << (long long)ln.a.x << " " << (long long)ln.a.y << " " << (long long)ln.c << "\n";
            return;
        }
        assert(0);
    }
};


line bisector(const vec& a, const vec& b) {
    vec d = a - b;
    ll c = d * a + d * b;
    ll f = 2 * (d * a) - c;
    assert(f > 0);
    if (c % 2 == 0) {
        return line(d, c / 2);
    }
    return line(vec(d.x * 2, d.y * 2), c);
}


flt dist2(const vec& a, const array<ll, 3>& b) {
    flt dx = (a.x - (flt)(b[0]) / b[2]);
    flt dy = (a.y - (flt)(b[1]) / b[2]);
    return dx * dx + dy * dy;
}


flt dist(const vec& a, const array<ll, 3>& b) {
    return sqrt(dist2(a, b));
}


int n;
vector<vec> a;
vector<vec> hull;


void build_hull() {
    auto s = a;
    int j = 0;
    for (int i = 1; i < n; i += 1) {
        if (s[i].x < s[j].x or (s[i].x == s[j].x and s[i].y < s[j].y)) {
            j = i;
        }
    }
    swap(s[0], s[j]);
    sort(s.begin() + 1, s.end(), [&](const vec& p, const vec& q) {
        ll biba = (p - s[0]) % (q - s[0]);
        if (biba != 0) {
            return biba > 0;
        }
        return (p - s[0]).len2() < (q - s[0]).len2();
        });
    hull = { s[0] };
    for (int i = 1; i < n; i += 1) {
        auto v = s[i];
        while ((int)hull.size() >= 2 and
            (hull.back() - hull[(int)hull.size() - 2]) % (v - hull[(int)hull.size() - 2]) <= 0) {
            hull.pop_back();
        }
        hull.push_back(v);
    }
}


void solve_lines() {
    assert((int)hull.size() > 0);
    if ((int)hull.size() == 1) {
        auto v = hull[0];
        opt::opt_line(line(v, v * v), 0);
        return;
    }
    int m = (int)hull.size();
    for (int i = 0; i < m; i += 1) {
        auto v = (hull[(i + 1) % m] - hull[i]).rotate90();
        int l = 0;
        int r = (n - 1);
        while (r - l > 4) {
            int m1 = (2 * l + r) / 3;
            int m2 = (l + 2 * r) / 3;
            if (v * (hull[(i + 1 + m1) % m] - hull[i]) > v * (hull[(i + 1 + m2) % m] - hull[i])) {
                r = m2;
            } else {
                l = m1;
            }
        }
        vec f = hull[i];
        for (int j = l; j <= r; j += 1) {
            auto t = hull[(i + 1 + j) % m];
            if ((f - hull[i]) * v < (t - hull[i]) * v) {
                f = t;
            }
        }
        ll c = hull[i] * v + f * v;
        line ln;
        if (c % 2 == 0) {
            ln = line(v, c / 2);
        } else {
            ln = line(vec(v.x * 2, v.y * 2), c);
        }
        flt rad = ((f - hull[i]) * v) / v.len() / 2;
        opt::opt_line(ln, rad);
    }
}


pair<flt, flt> try_point(const array<ll, 3>& u) {
    flt mx = 0;
    flt mn = 1e20;
    for (auto v : a) {
        flt d = dist2(v, u);
        mx = max(mx, d);
        mn = min(mn, d);
    }
    mx = sqrt(mx);
    mn = sqrt(mn);
    opt::opt_circle(u, (mx + mn) / 2, (mx - mn) / 2);
    return { mn, mx };
}


void solve_circles_slow() {
    vector<line> lines;
    for (int i = 0; i < n; i += 1) {
        for (int j = i + 1; j < n; j += 1) {
            lines.push_back(bisector(a[i], a[j]));
        }
    }
    for (int i = 0; i < (int)lines.size(); i += 1) {
        for (int j = i + 1; j < (int)lines.size(); j += 1) {
            auto lni = lines[i];
            auto lnj = lines[j];
            if (lni.a % lnj.a != 0) {
                auto u = intersect(lni, lnj);
                try_point(u);
            }
        }
    }
}


deque<line> intersect_halfplanes(const vector<line>& _lns) {
    vector<line> nlns = { line(vec(1, 0), -1e11),
                            line(vec(0, 1), -1e11),
                            line(vec(-1, 0), -1e11),
                            line(vec(0, -1), -1e11) };
    vector<line> lns((int)_lns.size() + 4);
    merge(all(_lns), all(nlns), lns.begin());
    // sort(all(lns));
    deque<line> d;
    for (auto ln : lns) {
        if (!d.empty() and d.back().a % ln.a == 0) {
            assert(d.back().a * ln.a > 0);
            if (d.back().normc() > ln.normc()) {
                continue;
            } else {
                d.pop_back();
            }
        }
        while ((int)d.size() >= 2 and !ln.strict_contains(intersect(d.back(), d[(int)d.size() - 2]))) {
            d.pop_back();
        }
        d.push_back(ln);
    }
    while ((int)d.size() >= 3) {
        if (!d.back().strict_contains(intersect(d[0], d[1]))) {
            d.pop_front();
            continue;
        }
        if (!d[0].strict_contains(intersect(d.back(), d[(int)d.size() - 2]))) {
            d.pop_back();
            continue;
        }
        if ((int)d.size() >= 4) {
            if (!d[(int)d.size() - 2].strict_contains(intersect(d[0], d[1]))) {
                d.pop_front();
                continue;
            }
            if (!d[1].strict_contains(intersect(d.back(), d[(int)d.size() - 2]))) {
                d.pop_back();
                continue;
            }
        }
        break;
    }
    assert((int)d.size() >= 3);
    return d;
}


vector<deque<line>> nearest, furthest;


void build_nearest() {
    nearest.resize(n);
    for (int i = 0; i < n; i += 1) {
        vector<vec> b = a;
        b.erase(b.begin() + i);
        sort(all(b), [&](const vec& p, const vec& q) {
            return (a[i] - p) < (a[i] - q);
            });
        vector<line> lns;
        lns.reserve(n - 1);
        for (auto v : b) {
            lns.push_back(bisector(a[i], v));
        }
        nearest[i] = intersect_halfplanes(lns);
    }
}


void build_furthest() {
    int m = (int)hull.size();
    furthest.resize(m);
    for (int i = 0; i < m; i += 1) {
        vector<vec> b = hull;
        b.erase(b.begin() + i);
        rotate(b.begin(), b.begin() + i, b.end());
        vector<line> lns;
        lns.reserve(m - 1);
        for (auto v : b) {
            lns.push_back(bisector(v, hull[i]));
        }
        int mn = 0;
        for (int j = 1; j < (int)lns.size(); j += 1) {
            if (lns[j] < lns[mn]) {
                mn = j;
            }
        }
        rotate(lns.begin(), lns.begin() + mn, lns.end());
        furthest[i] = intersect_halfplanes(lns);
    }
}





void solve_circles() {
    build_nearest();
    build_furthest();
    for (auto& lns : nearest) {
        for (int i = 0; i < (int)lns.size(); i += 1) {
            int j = (i + 1) % (int)lns.size();
            auto v = intersect(lns[i], lns[j]);
            try_point(v);
        }
    }
    for (auto& lns : furthest) {
        for (int i = 0; i < (int)lns.size(); i += 1) {
            int j = (i + 1) % (int)lns.size();
            auto v = intersect(lns[i], lns[j]);
            try_point(v);
        }
    }
    int m = (int)hull.size();
    rep(s, n) rep(t, m) {
        auto& lnss = nearest[s];
        auto& lnst = furthest[t];
        rep(i, (int)lnss.size()) rep(j, (int)lnst.size()) {
            if (lnss[i].a % lnst[j].a == 0) {
                continue;
            }
            int pi = (i + (int)lnss.size() - 1) % (int)lnss.size();
            int ni = (i + 1) % (int)lnss.size();
            int pj = (j + (int)lnst.size() - 1) % (int)lnst.size();
            int nj = (j + 1) % (int)lnst.size();
            auto v = intersect(lnss[i], lnst[j]);
            if (lnss[pi].strict_contains(v) and
                lnss[ni].strict_contains(v) and
                lnst[pj].strict_contains(v) and
                lnst[nj].strict_contains(v)) {
                flt mn = dist(a[s], v);
                flt mx = dist(hull[t], v);
                opt::opt_circle(v, (mx + mn) / 2, (mx - mn) / 2);
            }
        }
    }
}


void solve() {
    build_hull();
    solve_lines();
    solve_circles();
}


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    a.resize(n);
    for (int i = 0; i < n; i += 1) {
        long long x, y;
        cin >> x >> y;
        a[i] = vec(x, y);
    }
    solve();
    opt::print();
    return 0;
}

/*
4
2 1
1 3
2 4
7 2


7
26919 7739
85584 91359
47712 21058
13729 26355
16636 96528
88747 93023
46770 1150

10
756 624
252 208
504 416
378 312
203 287
329 391
0 0
707 703
126 104
581 599


*/