#include <bits/stdc++.h>
using namespace std;
const int INF = 1.01e9;
bool eq(long double A, long double B) { return abs(A - B) < 1e-9; }
bool ls(long double A, long double B) { return A < B && !eq(A, B); }
bool le(long double A, long double B) { return A < B || eq(A, B); }
struct pt {
  long double x, y;
  pt() {}
  pt(long double xx, long double yy) : x(xx), y(yy) {}
  pt operator+(pt A) { return pt(x + A.x, y + A.y); }
  pt operator-(pt A) { return pt(x - A.x, y - A.y); }
  pt operator*(long double k) { return pt(x * k, y * k); }
  pt operator/(long double k) {
    assert(abs(k) > 1e-20);
    return pt(x / k, y / k);
  }
  long double operator*(pt A) { return x * A.y - y * A.x; }
  long double operator%(pt A) { return x * A.x + y * A.y; }
  bool operator==(pt A) { return eq(x, A.x) && eq(y, A.y); }
  bool operator!=(pt A) { return !eq(x, A.x) || !eq(y, A.y); }
  long double len() { return sqrt(x * x + y * y); }
  long double len2() { return x * x + y * y; }
  pt rotate() { return pt(-y, x); }
  pt norm() { return (*this) / len(); }
  void read() {
    double xx, yy;
    scanf("%lf%lf", &xx, &yy);
    x = xx;
    y = yy;
  }
  void Epr() { cerr << "x y: " << x << " " << y << endl; }
};
struct Line {
  pt O, v;
  int id;
  Line() {}
  Line(pt A, pt B) : O(A), v((B - A).norm()) {}
  pt operator*(Line l) {
    pt u = l.v.rotate();
    assert(abs(v % u) > 1e-20);
    long double t = (l.O - O) % u / (v % u);
    return O + v * t;
  }
  void Epr() {
    cerr << "v: " << v.x << " " << v.y << endl;
    cerr << "O: " << O.x << " " << O.y << endl;
  }
};
int getPart(pt v) { return ls(0, v.y) || (eq(0, v.y) && ls(v.x, 0)); }
int cmpV(pt a, pt b) {
  int partA = getPart(a);
  int partB = getPart(b);
  if (partA < partB) return -1;
  if (partA > partB) return 1;
  if (eq(0, a * b)) return 0;
  if (0 < a * b) return -1;
  return 1;
}
bool planeInt(vector<Line> l, pt& ret) {
  int n = l.size();
  int cur = 0;
  for (int i = 0; i < n;) {
    int j = i;
    for (; i < n && cmpV(l[j].v, l[i].v) == 0 && cmpV(l[i].v, l[j].v) == 0; i++)
      ;
    l[cur++] = l[i - 1];
  }
  n = cur;
  for (int i = 0; i < n; i++) l[i].id = i;
  cur = 0;
  vector<Line> st(n * 2);
  for (int tt = 0; tt < 2; tt++) {
    for (int i = 0; i < n; i++) {
      for (; cur >= 2; cur--) {
        if (eq(st[cur - 1].v * l[i].v, 0)) return 0;
        pt G = st[cur - 1] * l[i];
        if (!le(st[cur - 2].v * (G - st[cur - 2].O), 0)) break;
      }
      st[cur++] = l[i];
      if (cur >= 2 && le(st[cur - 2].v * st[cur - 1].v, 0)) return 0;
    }
  }
  vector<int> use(n, -1);
  int left = -1, right = -1;
  for (int i = 0; i < cur; i++) {
    if (use[st[i].id] == -1) {
      use[st[i].id] = i;
    } else {
      left = use[st[i].id];
      right = i;
      break;
    }
  }
  vector<Line> tmp;
  for (int i = left; i < right; i++) tmp.push_back(st[i]);
  if (!tmp.empty()) {
    assert(tmp.size() >= 2);
    ret = tmp[0] * tmp[1];
    return true;
  }
  return false;
}
bool checkPoint(vector<Line> l, pt& ret) {
  random_shuffle((l).begin(), l.end());
  pt A = l[0].O;
  for (int i = 1; i < (int)(l).size(); i++) {
    if (!le(0, l[i].v * (A - l[i].O))) {
      long double mn = -INF;
      long double mx = INF;
      for (int j = 0; j < i; j++) {
        if (eq(l[j].v * l[i].v, 0)) {
          if (l[j].v % l[i].v < 0 && (l[j].O - l[i].O) % l[i].v.rotate() <= 0) {
            return false;
          }
        } else {
          pt u = l[j].v.rotate();
          long double proj = (l[j].O - l[i].O) % u / (l[i].v % u);
          if (l[i].v * l[j].v > 0) {
            mx = min(mx, proj);
          } else {
            mn = max(mn, proj);
          }
        }
      }
      if (mn <= mx) {
        A = l[i].O + l[i].v * mn;
      } else {
        return false;
      }
    }
  }
  ret = A;
  return true;
}
long double fast(vector<pt> p, pt& R1, pt& R2) {
  int n = p.size();
  auto build = [&](int st, int cnt, long double d, pt& ret) {
    vector<Line> l;
    for (int i = 0; i < cnt; i++) {
      pt A = p[(st + i) % n];
      pt B = p[(st + i + 1) % n];
      pt v = (B - A).norm().rotate();
      l.push_back(Line(A, B));
      l.push_back(Line(B + v * d, A + v * d));
    }
    return checkPoint(l, ret);
  };
  pair<pt, pt> sert;
  auto check = [&](long double d) {
    vector<int> go(n);
    vector<pt> how(n);
    int cur = 0;
    pt lastRet = pt(0, 0);
    for (int i = 0; i < n; i++) {
      cur = max(cur, 1);
      for (; cur < n; cur++) {
        pt ret;
        if (build(i, cur + 1, d, ret)) {
          lastRet = ret;
        } else {
          break;
        }
      }
      how[i] = lastRet;
      go[i] = cur;
      cur--;
    }
    for (int i = 0; i < n; i++) {
      if (go[i] + go[(i + go[i]) % n] >= n) {
        sert = {how[i], how[(i + go[i]) % n]};
        return true;
      }
    }
    return false;
  };
  long double l = 0;
  long double r = 1e6;
  for (int it = 0; it < 70; it++) {
    if (check((l + r) / 2)) {
      r = (l + r) / 2;
    } else {
      l = (l + r) / 2;
    }
  }
  R1 = sert.first;
  R2 = sert.second;
  return r;
}
vector<pt> convexHull(vector<pt> p) {
  sort((p).begin(), p.end(), [](pt A, pt B) {
    return ls(A.x, B.x) || (eq(A.x, A.y) && ls(A.y, B.y));
  });
  vector<pt> st;
  for (int tt = 0; tt < 2; tt++) {
    int cur = st.size();
    for (auto A : p) {
      for (; (int)(st).size() >= cur + 2 &&
             le((st.back() - st[st.size() - 2]) * (A - st.back()), 0);
           st.pop_back())
        ;
      st.push_back(A);
    }
    st.pop_back();
    reverse((p).begin(), p.end());
  }
  return st;
}
int main() {
  if (1) {
    int n;
    scanf("%d", &n);
    vector<pt> p(n);
    for (int i = 0; i < n; i++) {
      p[i].read();
    }
    pt R1, R2;
    long double r = fast(p, R1, R2);
    printf("%.17f\n", (double)r);
    printf("%.17f %.17f\n", (double)R1.x, (double)R1.y);
    printf("%.17f %.17f\n", (double)R2.x, (double)R2.y);
  } else {
    for (int tt = 237;; tt++) {
      srand(tt);
      cerr << "tt"
           << " = " << tt << endl;
      int n;
      vector<pt> p;
      while (true) {
        n = rand() % 300 + 1;
        p.clear();
        int T = 100;
        for (int i = 0; i < n; i++) {
          p.push_back(pt(rand() % T, rand() % T));
        }
        p = convexHull(p);
        if (p.size() >= 3) {
          break;
        }
      }
      pt R1, R2;
      cerr << "p.size()"
           << " = " << p.size() << endl;
      fast(p, R1, R2);
    }
  }
  return 0;
}
