Problem: Barney has finally found the one, a beautiful young lady named Lyanna. The problem is, Lyanna and Barney are trapped in Lord Loss' castle. This castle has shape of a convex polygon of n points. Like most of castles in Demonata worlds, this castle has no ceiling.

<image>

Barney and Lyanna have an escape plan, but it requires some geometry knowledge, so they asked for your help.

Barney knows that demons are organized and move in lines. He and Lyanna want to wait for the appropriate time so they need to watch for the demons. Each of them wants to stay in a point inside the castle (possibly on edges or corners), also they may stay in the same position. They both want to pick a real number r and watch all points in the circles with radius r around each of them (these two circles may overlap).

<image>

We say that Barney and Lyanna are watching carefully if and only if for every edge of the polygon, at least one of them can see at least one point on the line this edge lies on, thus such point may not be on the edge but it should be on edge's line. Formally, each edge line should have at least one common point with at least one of two circles.

The greater r is, the more energy and focus they need. So they asked you to tell them the minimum value of r such that they can watch carefully.

Input

The first line of input contains a single integer n (3 ≤ n ≤ 300) — the number of castle polygon vertices.

The next n lines describe the polygon vertices in counter-clockwise order. i-th of them contains two integers xi and yi (|xi|, |yi| ≤ 104) — the coordinates of i-th point of the castle. It is guaranteed that given points form a convex polygon, in particular, any three of them do not line on the same line.

Output

In the first line print the single number r — minimum radius of guys' watching circles.

In the second line print the pair of coordinates of point where Barney should stay.

In the third line print the pair of coordinates of point where Lyanna should stay.

Points should lie inside the polygon.

Coordinates may not be integers. If there are multiple answers print any of them.

Your answer will be considered correct if its absolute or relative error doesn't exceed 10 - 6.

Examples

Input

4
-41 67
-16 20
25 25
-36 85


Output

0
-16 20
-36 85


Input

7
-7 54
-5 31
-2 17
20 19
32 23
34 27
26 57


Output

2.9342248
32.019503 23.0390067
-6.929116 54.006444

Note

In the first example guys can stay in opposite corners of the castle.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(double(-1));
const double INF = 1e10;
const double EPS = 1e-8;
inline double sqr(double x) { return x * x; }
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  void in() { scanf("%lf%lf", &x, &y); }
};
bool operator<(const PT &p1, const PT &p2) {
  if (fabs(p1.x - p2.x) > EPS) return p1.x < p2.x;
  return p1.y + EPS < p2.y;
}
bool operator==(const PT &p1, const PT &p2) {
  return fabs(p1.x - p2.x) < EPS && fabs(p1.y - p2.y) < EPS;
}
PT operator+(PT p1, PT p2) { return PT(p1.x + p2.x, p1.y + p2.y); }
PT operator-(PT p1, PT p2) { return PT(p1.x - p2.x, p1.y - p2.y); }
PT operator*(PT p, double c) { return PT(p.x * c, p.y * c); }
PT operator/(PT p, double c) { return PT(p.x / c, p.y / c); }
double dis(PT p) { return sqrt(sqr(p.x) + sqr(p.y)); }
double dis2(PT p) { return sqr(p.x) + sqr(p.y); }
double dis2(PT p1, PT p2) { return sqr(p1.x - p2.x) + sqr(p1.y - p2.y); }
double dis(PT p1, PT p2) { return sqrt(dis2(p1, p2)); }
double vect(PT p1, PT p2) { return p1.x * p2.y - p2.x * p1.y; }
double scal(PT p1, PT p2) { return p1.x * p2.x + p1.y * p2.y; }
double getAngle(PT p) { return atan2(p.y, p.x); }
double vect(PT p, PT p1, PT p2) { return vect(p1 - p, p2 - p); }
double scal(PT p, PT p1, PT p2) { return scal(p1 - p, p2 - p); }
double getAngle(PT p, PT p1, PT p2) {
  return getAngle(p2 - p) - getAngle(p1 - p);
}
double getAngle180(PT p, PT p1, PT p2) {
  return acos(scal(p, p1, p2) / dis(p, p1) / dis(p, p2));
}
double disToLine(PT p, PT p1, PT p2) {
  return fabs(vect(p, p1, p2)) / dis(p1, p2);
}
double disToSeg(PT p, PT p1, PT p2) {
  if (scal(p1, p, p2) < 0) return dis(p, p1);
  if (scal(p2, p, p1) < 0) return dis(p, p2);
  return disToLine(p, p1, p2);
}
bool onLine(PT p, PT p1, PT p2) { return fabs(vect(p1 - p, p2 - p)) < EPS; }
bool onSeg(PT p, PT p1, PT p2) {
  if (!onLine(p, p1, p2)) return 0;
  return (p1.x - p.x) * (p2.x - p.x) < EPS && (p1.y - p.y) * (p2.y - p.y) < EPS;
}
PT projection(PT a, PT b, PT p) {
  return a + (a - b) * scal(p - a, a - b) / dis2(a - b);
}
int posLineLine(PT p1, PT p2, PT p3, PT p4, PT &p) {
  double s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
  if (fabs(s1 - s2) < EPS) {
    if (fabs(s1) < EPS) return 2;
    return 0;
  }
  p = p3 + (p4 - p3) * s1 / (s1 - s2);
  return 1;
}
int posCirLine(PT p, double r, PT p1, PT p2, PT *q) {
  double a, b, c, d2, d;
  a = dis2(p1, p2);
  b = scal(p1, p, p2);
  c = dis2(p, p1) - sqr(r);
  d2 = sqr(b) - a * c;
  if (d2 < -EPS) return 0;
  d = sqrt(fabs(d2));
  q[0] = p1 + (p2 - p1) * (b + d) / a;
  if (d2 < EPS) return 1;
  q[1] = p1 + (p2 - p1) * (b - d) / a;
  return 2;
}
int posCirCir(PT p1, double r1, PT p2, double r2, PT *q) {
  double dx, dy, d, e, f2, f;
  dx = p2.x - p1.x, dy = p2.y - p1.y;
  d = dis(p1, p2);
  e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
  f2 = sqr(r1) - sqr(e);
  if (f2 < -EPS) return 0;
  f = sqrt(fabs(f2));
  q[0] = PT(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
  if (f2 < EPS) return 1;
  q[1] = PT(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
  return 2;
}
double calcArea(PT *p, int n) {
  double rlt = 0;
  for (int i = 0; i < n; i++) rlt += vect(p[i], p[(i + 1) % n]);
  return rlt / 2;
}
int inPolygon(PT p, PT *q, int m) {
  PT p1, p2;
  int k = 0;
  for (int i = 0; i < m; i++) {
    p1 = q[i], p2 = q[(i + 1) % m];
    if (onSeg(p, p1, p2)) return 2;
    if (p1.y > p2.y) swap(p1, p2);
    if (p1.y < p.y + EPS && p.y + EPS < p2.y && vect(p, p1, p2) > 0) k++;
  }
  return k % 2;
}
PT innercenter(PT a, PT b, PT c) {
  double A = dis(b - c);
  double B = dis(c - a);
  double C = dis(a - b);
  return PT((A * a.x + B * b.x + C * c.x) / (A + B + C),
            (A * a.y + B * b.y + C * c.y) / (A + B + C));
}
int convex_hull(PT *p, int n, PT *q) {
  sort(p, p + n);
  n = unique(p, p + n) - p;
  if (n == 1) {
    q[0] = p[0];
    return 1;
  }
  int m = 0;
  for (int i = 0; i < n; i++) {
    while (m > 1 && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
    q[m++] = p[i];
  }
  int k = m;
  for (int i = n - 2; i >= 0; i--) {
    while (m > k && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
    q[m++] = p[i];
  }
  return --m;
}
const int N = 666;
const int M = 333;
PT P[N];
PT Q[M][M];
double R[M][M];
int nxt[N];
double calc(PT A, double alpha, int from, int to) {
  PT B = A + PT(cos(alpha), sin(alpha));
  PT C;
  for (int i = from + 1; i < to; i++) {
    int ret = posLineLine(A, B, P[i], P[i + 1], C);
    assert(ret == 1);
    if (onSeg(C, P[i], P[i + 1])) break;
  }
  double ret = 0;
  for (int i = from; i <= to; i++) {
    ret = max(ret, disToLine(C, P[i], P[i + 1]));
  }
  return ret;
}
int main() {
  double ans = INF;
  PT T[2];
  int n;
  scanf("%d", &n);
  for (int i = 0; i < n; i++) P[i].in();
  if (n == 3 || n == 4) {
    puts("0");
    printf("%.10lf %.10lf\n", P[0].x, P[0].y);
    printf("%.10lf %.10lf\n", P[2].x, P[2].y);
    return 0;
  }
  for (int i = n; i < n + n; i++) P[i] = P[i - n];
  for (int i = 0; i < n; i++) {
    int t = i + n - 3;
    for (int j = i + 1; j < i + n - 2; j++) {
      if (vect(P[i + 1] - P[i], P[j + 1] - P[j]) < EPS) {
        t = j - 1;
        break;
      }
    }
    PT A;
    int a[] = {i, t + 1}, b[] = {t, i + n - 1};
    PT O[2];
    double r[2];
    for (int T = 0; T < 2; T++) {
      int to = b[T];
      int f = a[T];
      if (f + 1 == to) {
        r[T] = 0;
        O[T] = P[f + 1];
      } else {
        int ret = posLineLine(P[f], P[f + 1], P[to], P[to + 1], A);
        assert(ret == 1);
        double st = getAngle(P[to] - A);
        double en = getAngle(P[f] - A);
        if (en < st) en += 2 * PI;
        for (int times = 0; times < 100; times++) {
          double md1 = (st + st + en) / 3, md2 = (st + en + en) / 3;
          double ret1 = calc(A, md1, f, to);
          double ret2 = calc(A, md2, f, to);
          if (ret1 > ret2)
            st = md1;
          else
            en = md2;
        }
        PT B = A + PT(cos(st), sin(st));
        PT C;
        for (int j = f + 1; j < to; j++) {
          int ret = posLineLine(A, B, P[j], P[j + 1], C);
          assert(ret == 1);
          if (onSeg(C, P[j], P[j + 1])) break;
        }
        double d = 0;
        for (int j = f; j <= to; j++) {
          d = max(d, disToLine(C, P[j], P[j + 1]));
        }
        r[T] = d;
        O[T] = C;
      }
    }
    if (ans > max(r[0], r[1])) {
      ans = max(r[0], r[1]);
      T[0] = O[0];
      T[1] = O[1];
    }
  }
  printf("%.10lf\n%.10lf %.10lf\n%.10lf %.10lf\n", ans, T[0].x, T[0].y, T[1].x,
         T[1].y);
}