#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
using ldb = long double;
struct point {
    ldb x, y;
    point operator+(const point& o) const { return {x + o.x, y + o.y}; }
    point operator-(const point& o) const { return {x - o.x, y - o.y}; }
    point operator*(const ldb& o) const { return {x * o, y * o}; }

    ldb operator^(const point& o) const { return x * o.y - o.x * y; }
    ldb operator*(const point& o) const { return x * o.x + o.y * y; }
};
struct seg {
    point a, b;
    void norm() {
        if ((a ^ b) < 0) swap(a, b);
    }
};

point fs(const point& a, const point& b, const point& p) {
    auto v = b - a;
    auto q = a + v * ((p - a) * v / (v * v));
    return q * 2 - p;
}

seg fs(const seg& a, const seg& p) {
    auto p1 = fs(a.a, a.b, p.a);
    auto p2 = fs(a.a, a.b, p.b);
    auto ans = seg{p1, p2};
    ans.norm();
    return ans;
}

point inter(const point& p, const seg& a) {
    auto v = a.a - a.b;
    auto v1 = p ^ v;
    auto v2 = (a.b ^ v);
    return p * (v2 / v1);
}
const ldb eps = 1e-11;

bool check(point& a, point& b, const seg& s) {
    auto c = s.a, d = s.b;
    auto v1 = b - a, v2 = d - c;
    ldb val = ((a - c) ^ v1) / (v2 ^ v1);
    return -eps <= val && val <= 1 + eps;
}

point inter(point& a, point& b, const seg& s) {
    auto c = s.a, d = s.b;
    auto v1 = b - a, v2 = d - c;
    ldb val = ((a - c) ^ v1) / (v2 ^ v1);
    return c + v2 * val;
}

void cmx(ldb& a, ldb b) {
    a = max(a, b);
}
int main() {
    int n;
    cin >> n;
    vector<point> a(n);
    vector<ldb> ans(n + 10);
    for (int i = 0; i < n; ++i) cin >> a[i].x >> a[i].y;
    vector<seg> s(n);
    for (int i = 0; i < n; ++i) s[i] = {a[i], a[i == n - 1 ? 0 : i + 1]}, s[i].norm();

    vector<int> vis(n);
    vector<seg> stk;
    auto update_ans = [&]() {
        for (int i = 0; i < stk.size(); ++i) {
            for (int j = 0; j < stk.size(); ++j) {
                if (i == j) continue;
                int cnt = 0;
                for (auto p : {stk[i].a, stk[i].b}) {
                    for (auto q : {stk[j].a, stk[j].b}) {
                        if (!check(p, q, stk.back())) continue;
                        auto begin = inter(p, q, stk.back());
                        for (int k = 0; k < stk.size() - 1; ++k) {
                            if (!check(p, q, stk[k])) break;
                            auto end = inter(p, q, stk[k]);
                            auto u = end - begin;
                            cmx(ans[k + 1], u * u);
                        }
                    }
                }
            }
        }
    };

    auto dfs = [&](auto self) -> void {
        for (int i = 0; i < n; ++i) {
            seg tmp = s[i];
            for (const auto& u : stk) tmp = fs(u, tmp);
            stk.push_back(tmp);
            for (int j = 0; j < n; ++j) {
                stk.push_back(s[j]);
                update_ans();
                stk.pop_back();
            }
            stk.pop_back();
        }
        if (stk.size() == n) return;
        for (int i = 0; i < n; ++i) {
            if (vis[i]) continue;
            seg tmp = s[i];
            for (const auto& u : stk) tmp = fs(u, tmp);
            stk.push_back(tmp);
            vis[i] = 1;
            self(self);
            vis[i] = 0;
            stk.pop_back();
        }
    };
    dfs(dfs);

    for (int i = 1; i <= n + 1; ++i) cmx(ans[i], ans[i - 1]), printf("%.20LF\n", sqrtl(ans[i]));
}

/*
4
-10 -97
13 -98
90 50
42 97
*/