#include <bits/stdc++.h>
using namespace std;
double sq(double x) { return x * x; }
template <typename T>
struct Point {
  T x, y;
  Point() {}
  Point(T x, T y) : x(x), y(y) {}
  Point<T> operator+(const Point<T> &rhs) const {
    return Point<T>(x + rhs.x, y + rhs.y);
  }
  Point<T> operator-(const Point<T> &rhs) const {
    return Point<T>(x - rhs.x, y - rhs.y);
  }
  Point<T> operator*(const T &rhs) const { return Point<T>(x * rhs, y * rhs); }
  Point<T> operator/(const T &rhs) const { return Point<T>(x / rhs, y / rhs); }
  Point<T> &operator+=(const Point<T> &rhs) { return *this = *this + rhs; }
  Point<T> &operator-=(const Point<T> &rhs) { return *this = *this - rhs; }
  Point<T> &operator*=(const T &rhs) { return *this = *this * rhs; }
  Point<T> &operator/=(const T &rhs) { return *this = *this / rhs; }
  T cross(const Point<T> &rhs) const { return x * rhs.y - y * rhs.x; }
  T dot(const Point<T> &rhs) const { return x * rhs.x + y * rhs.y; }
  double len() const { return sqrt(sq(x) + sq(y)); }
};
template <typename T>
struct Segment {
  Point<T> a, b;
  Segment() {}
  Segment(const Point<T> &a, const Point<T> &b) : a(a), b(b) {}
  Point<T> direction() const { return b - a; }
  T cross(const Segment &rhs) const {
    return direction().cross(rhs.direction());
  }
  T dot(const Segment &rhs) const { return direction().dot(rhs.direction()); }
};
double distance(const Point<double> &a, const Point<double> &b) {
  return (a - b).len();
}
Point<double> intersection(const Segment<double> &s1,
                           const Segment<double> &s2) {
  double a1 = (s2.a - s1.a).cross(s2.b - s1.a),
         a2 = (s2.b - s1.b).cross(s2.a - s1.b);
  double r1 = a1 / (a1 + a2), r2 = a2 / (a1 + a2);
  return s1.a * r2 + s1.b * r1;
}
int dcmp(double a, double b = 0) {
  const double EPS = 1e-8;
  if (abs(a - b) < EPS) return 0;
  return a < b ? -1 : 1;
}
bool same_direction(const Segment<double> &s1, const Segment<double> &s2) {
  Point<double> d1 = s1.direction(), d2 = s2.direction();
  return dcmp(d1.cross(d2)) == 0 && dcmp(d1.dot(d2)) == 1;
}
double atan(const Segment<double> &seg) {
  Point<double> d = seg.direction();
  return atan2(d.y, d.x);
}
vector<Segment<double> > HalfPlaneIntersection(
    vector<Segment<double> > segments) {
  const auto judge = [](const Segment<double> &s1, const Segment<double> &s2,
                        const Segment<double> &s3) -> bool {
    if (dcmp(s1.direction().cross(s3.direction())) < 0) return false;
    Point<double> inter12 = intersection(s1, s2),
                  inter23 = intersection(s2, s3);
    return dcmp((inter12 - inter23).dot(s2.direction())) >= 0;
  };
  int n = 0;
  for (int i = 1; i < segments.size(); i++) {
    if (!same_direction(segments[n], segments[i])) segments[++n] = segments[i];
  }
  segments.erase(segments.begin() + n + 1, segments.end());
  list<Segment<double> > res;
  for (const Segment<double> &i : segments) {
    while (res.size() >= 2 &&
           judge(*prev(res.end(), 2), *prev(res.end(), 1), i))
      res.pop_back();
    while (res.size() >= 2 && judge(i, *res.begin(), *next(res.begin())))
      res.pop_front();
    if (res.size() >= 2 && judge(*prev(res.end()), i, *res.begin())) continue;
    if (res.size() >= 2 &&
        dcmp(prev(res.end())->cross(*prev(res.end(), 2))) < 0 &&
        dcmp(i.cross(*prev(res.end(), 2))) > 0) {
      Point<double> inter12 =
                        intersection(*prev(res.end(), 1), *prev(res.end(), 2)),
                    interi2 = intersection(i, *prev(res.end(), 2));
      if (dcmp((interi2 - inter12).dot(prev(res.end(), 2)->direction())) >= 0)
        return {};
    }
    if (res.size() == 1 && dcmp(res.front().cross(i)) == 0 &&
        dcmp(res.front().dot(i)) == -1 &&
        dcmp((res.front().a - i.b).cross(res.front().a - i.a)) >= 0)
      return {};
    res.push_back(i);
  }
  return vector<Segment<double> >(res.begin(), res.end());
}
const int MAX_N = 303, BINARY_SEARCH_COUNT = 50;
int N;
Point<double> castle[MAX_N];
struct Record {
  Segment<double> s;
  int id;
  Record() {}
  Record(Segment<double> s, int id) : s(s), id(id) {}
};
bool check(double radius, Point<double> &pointA, Point<double> &pointB) {
  vector<Record> records;
  Point<double> last = castle[N];
  for (int i = 1; i <= N; i++) {
    records.emplace_back(Segment<double>(last, castle[i]), 0);
    Point<double> dir = castle[i] - last;
    swap(dir.x, dir.y);
    dir.x *= -1;
    dir *= radius / dir.len();
    records.emplace_back(Segment<double>(castle[i] + dir, last + dir), i);
    last = castle[i];
  }
  sort(records.begin(), records.end(), [](const Record &r1, const Record &r2) {
    const Segment<double> &s1 = r1.s, &s2 = r2.s;
    Point<double> d1 = s1.direction(), d2 = s2.direction();
    if (dcmp(d1.cross(d2)) == 0 && dcmp(d1.dot(d2)) > 0) {
      return (s1.a - s2.a).cross(s1.a - s2.b) > 0;
    }
    return atan2(d1.y, d1.x) < atan2(d2.y, d2.x);
  });
  static int rng[MAX_N];
  rng[0] = 0;
  static Point<double> res[MAX_N];
  for (int i = 1; i <= N; i++) {
    rng[i] = rng[i - 1];
    res[i] = res[i - 1];
    if (rng[i] % N + 1 == i) rng[i] = i, res[i] = castle[i];
    while (rng[i] % N + 1 != i) {
      int upd = rng[i] % N + 1;
      vector<Segment<double> > seg;
      for (const Record &rec : records) {
        if (rec.id == 0 || upd >= i && (rec.id >= i && rec.id <= upd) ||
            upd < i && (rec.id >= i || rec.id <= upd))
          seg.push_back(rec.s);
      }
      vector<Segment<double> > poss = HalfPlaneIntersection(seg);
      if (poss.empty())
        break;
      else
        rng[i] = upd, res[i] = intersection(poss[0], poss[1]);
    }
  }
  for (int i = 1; i <= N; i++) {
    int j = rng[i], k = rng[j % N + 1] % N + 1;
    if (j >= i && i <= k && k <= j || j < i && (k >= i || k <= j)) {
      pointA = res[i];
      pointB = res[j % N + 1];
      return true;
    }
  }
  return false;
}
int main() {
  scanf("%d", &N);
  for (int i = 1; i <= N; i++) {
    double x, y;
    scanf("%lf%lf", &x, &y);
    castle[i] = Point<double>(x, y);
  }
  double l = 1e-8, r = 1e5;
  Point<double> pointA, pointB;
  for (int i = 1; i <= BINARY_SEARCH_COUNT; i++) {
    double m = (l + r) / 2;
    if (check(m, pointA, pointB))
      r = m;
    else
      l = m;
  }
  check(l, pointA, pointB);
  printf("%.10lf\n", l);
  printf("%.10lf %.10lf\n", pointA.x, pointA.y);
  printf("%.10lf %.10lf\n", pointB.x, pointB.y);
}
