/*
TASK:atom
LANG:C++
KEYW: FUCK!!!!!!
*/
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <utility>
#include <queue>

//#warning the points on the edge of the hull

const int MAXN = 1 << 7;
const double epsilon = 1e-6;

template <class T> struct point {
    T x, y;
    point () {}
    point (T _x, T _y) : x (_x), y (_y) {}
    point (const point <T> &a) : x (a.x), y (a.y) {}
    point<T>& operator += (const point<T> &a) {x += a.x; y+=a.y; return *this;}
    point<T>& operator -= (const point<T> &a) {x -= a.x; y -=a.y; return *this;}
    point<T> operator + (const point<T> &a) const {point<T> ret (*this); ret += a; return ret;}
    point<T> operator - (const point<T> &a) const {point<T> ret (*this); ret -= a; return ret;}
    T operator * (const point<T> &a) const {return x * a.x + y * a.y;}
    T sq () const {return x * x + y * y;}
    double len () const {return sqrt (fabs (sq ()));}
    point<T>& mod () {double _len = len (); x /= _len; y /= _len; return *this;}
    point<T>& rotl () {std::swap (x, y); x *= -1; return *this;}
    point<T>& rotr () {std::swap (x, y); y *= -1; return *this;}
    point<T> operator / (T a) {point <T> ret (*this); ret.x /= a; ret.y /= a; return ret;}
    point<T> operator * (T a) {point <T> ret (*this); ret.x *= a; ret.y *= a; return ret;}    
};

template <class T>T S (const point<T> a, const point <T> b, const point <T> c) {
    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}

struct tri {
    int a, b, c;
    tri () {}
    tri (int _a, int _b, int _c) : a (_a), b (_b), c (_c) {}
};

int N;
point <int> vec[MAXN];

int hid[MAXN], hsz;
int lpid;

bool cmp (int a, int b) {
    static int tmp;
    return (tmp = S (vec[lpid], vec[a], vec[b])) ?
            tmp > 0:
            (vec[a] - vec[lpid]).sq () < (vec[b] - vec[lpid]).sq ();
}

void hull () {
    lpid = 0;
    int i;
    for (i = 1; i < N; ++i)
        if (vec[i].y < vec[lpid].y || vec[i].y == vec[lpid].y && vec[i].x > vec[lpid].x)
            lpid = i;

    int idx[MAXN];
    for (i = 0; i < N; ++i) idx[i] = i;
    idx[0] = lpid;
    idx[lpid] = 0;
    std::sort (idx + 1, idx + N, cmp);
//    for (i = 0; i < N; ++i) printf ("%d ", idx[i]); printf ("\n");

    hid[0] = idx[0];
    hid[1] = idx[1];
    hsz = 2;
    for (i = 2; i < N; ++i) {
        hid[hsz++] = idx[i];
        while (hsz > S (vec[hid[hsz-3]], vec[hid[hsz-2]], vec[hid[hsz-1]]) <= 0) {
            hid[hsz - 2] = hid[hsz - 1];
            --hsz;
        }
    }

//    for (i = 0; i < hsz; ++i) printf ("%d ", hid[i]); printf ("\n");
}

std::pair <point <double>, double> pans[MAXN * (1 << 3)];
int pans_size;

bool ma3x[MAXN][MAXN];
/*
inline double sq (double a) {return a * a;}
template <class T> inline double dst (const point<T> &a, const point <T> &b) {
    return sq (a.x - b.x) + sq (a.y - b.y);
}
*/

double mycos (const point <int> &a, const point <int> &b, const point <int> &c) {
//    printf ("%d %d  %d %d  %d %d\n", a.x, a.y, b.x, b.y, c.x, c.y);
//    printf ("%d -- %lf %lf\n", ((a - c) * (b - c)), (a - c).len (), (b - c).len ());
    return ((a - c) * (b - c)) / ((a - c).len () * (b - c).len ());
}

std::pair <point <double>, double> getRO (point <int> a, point <int> b, point <int> c, double cos) {
//    printf ("%d %d  %d %d  %d %d\n", a.x, a.y, b.x, b.y, c.x, c.y);
    double sina = sqrt (1 - cos * cos);
    double as = (b - a).len ();
    double R = as / (2 * sina);
    double dd = sqrt (R * R - (as / 2) * (as / 2));
//    printf ("as R dd %lf %lf %lf\n", as, R, dd);
    point <double> vtr (b.x - a.x, b.y - a.y);
    vtr.x /= 2; vtr.y /= 2;
    point <double> vtr2 (vtr);
    vtr2.mod ();
    vtr2.x *= dd; vtr2.y *= dd;
    if (cos * S (a, b, c) > 0) {
        vtr2.rotl ();
    } else {
        vtr2.rotr ();
    }
    vtr += vtr2;
    vtr += point <double> (a.x, a.y);
//    printf ("%lf %lf\n", vtr.x, vtr.y);    
//    printf ("R -- %lf\n", R);
//    printf ("------------\n");
    return std::make_pair (vtr, R);
}

void triang () {
    vec[N] = point<int> (vec[lpid].x, vec[lpid].y - 5);//lower than the lowest    
    std::queue <tri> q;
    q.push (tri (hid[0], hid[1], N));
    ma3x[hid[0]][hid[1]] = ma3x[hid[1]][hid[0]] = 1;

    int ex, i;
    tri crnt;
    double tmp;
    while (!q.empty ()) {
        crnt = q.front (); q.pop ();
//        printf ("popped %d %d %d\n", crnt.a, crnt.b, crnt.c);
        ex = S (vec[crnt.a], vec[crnt.b], vec[crnt.c]);
        ex = ex > 0 ? 1 : ex < 0 ? -1 : 0;
        double mincos = 2;
        int mid = -1;
        for (i = 0; i < N; ++i) {
            if (S (vec[crnt.a], vec[crnt.b], vec[i]) * ex < 0) {
                tmp = mycos (vec[crnt.a], vec[crnt.b], vec[i]);
//                printf ("try %d(%lf)(%lf)\n", i, tmp, mincos); fflush (stdout);
                if (tmp < mincos) {
                    mincos = tmp;
                    mid = i;
                }
            }
        }
        if (mid != -1) {
            pans[pans_size++] = getRO (vec[crnt.a], vec[crnt.b], vec[mid], mincos);
            if (!ma3x[crnt.a][mid]) {
                ma3x[crnt.a][mid] = ma3x[mid][crnt.a] = 1;
                q.push (tri (crnt.a, mid, crnt.b));
            }
            if (!ma3x[crnt.b][mid]) {
                ma3x[crnt.b][mid] = ma3x[mid][crnt.b] = 1;
                q.push (tri (crnt.b, mid, crnt.a));
            }
        }
    }
}

point <double> tod (point <int> a) {
    return point <double> (a.x, a.y);    
}


int main () {
    scanf ("%d", &N);

    int i, j;
    for (i = 0; i < N; ++i)
        scanf ("%d %d", &vec[i].x, &vec[i].y);
    
    hull ();
    triang ();
    
    hid[hsz] = hid[0];
    for (i = 0; i < hsz; ++i) {
        point <double> x (tod (vec[hid[i+1]] - vec[hid[i]]) / 2. + tod (vec[hid[i]]));
        double mdist = 1e10;
        for (j = 0; j < N; ++j)
            mdist <?= (x - tod (vec[j])).sq ();
        mdist = sqrt (mdist);
        pans[pans_size++] = std::make_pair (x, mdist);
//        printf ("%lf %lf   %lf--%d------\n", x.x, x.y, mdist, i);
    }
//    printf ("hsz %d\n", hsz);

    std::pair <point <double>, double> _ans (point <double> (0, 0), (double)-1);
    for (i = 0; i < pans_size; ++i) {
//        printf ("%lf  %lf %lf\n", pans[i].second, pans[i].first.x, pans[i].first.y);        
        for (j = 0; j < hsz && S (tod (vec[hid[j]]), tod (vec[hid[j+1]]), pans[i].first) > -epsilon; ++j);
        if (j == hsz && pans[i].second > _ans.second)
            _ans = pans[i];
    }
    printf ("%.2lf\n%.2lf %.2lf\n", _ans.second, _ans.first.x, _ans.first.y);

    return 0;
}
