#pragma GCC optimize("Ofast","unroll-loops","fast-math")
#include <bits/stdc++.h>
using namespace std;
typedef double ld;
const ld eps=1e-8;
typedef pair<ld,ld> pnt;
#define x first
#define y second
#define fi first
#define se second
typedef vector<pnt> poly;
pnt operator - (pnt a,pnt b) {
    return pnt(a.x-b.x,a.y-b.y);
}
pnt operator + (pnt a,pnt b) {
    return pnt(a.x+b.x,a.y+b.y);
}
ld cross(pnt a,pnt b) {
    return a.x*b.y-a.y*b.x;
}
ld dot(pnt a,pnt b) {
    return a.x*b.x+a.y*b.y;
}
ld len2(pnt a) {
    return dot(a,a);
}
ld len(pnt a) {
    auto t=len2(a);
    if(t<0) t=0;
    return sqrt(t);
}
pnt rot(pnt a) {
    return pnt(-a.y,a.x);
}
pnt operator * (pnt a,ld k) {
    return pnt(a.x*k,a.y*k);
}
pnt operator / (pnt a,ld k) {
    return pnt(a.x/k,a.y/k);
}
pnt rf(pnt a,pnt b,pnt c) {
    ld co=cross(b-a,c-a);
    pnt t=rot(b-a);
    return c-t*co/len2(t)*2;
}
poly rf(poly a,int u) {
    pnt A(a[u]),B(a[(u+1)%a.size()]);
    for(auto&x:a) x=rf(A,B,x);
    return a;
}
int n;
pair<pnt,pnt> st,ed;
vector<pair<pnt,pnt>> ms;
pnt lineinter(pnt s1,pnt e1,pnt s2,pnt e2) {
    ld co=cross(e1-s1,e2-s2);
    if(abs(co)<eps) return pnt(1e9,1e9);
    auto p=cross(e1-s2,e2-s2);
    auto q=cross(e2-s2,s1-s2);
    return (s1*p+e1*q)/co;
}
bool onseg(pnt s,pnt e,pnt p) {
    return abs(cross(s-p,e-p))<eps&&dot(p-s,p-e)<eps;
}
int sgn(ld x) {
    if(x>eps) return 1;
    if(x<-eps) return -1;
    return 0;
}
bool seginter(pnt a,pnt b,pnt c,pnt d) {
    ld oa=cross(d-c,a-c),ob=cross(d-c,b-c);
    ld oc=cross(b-a,c-a),od=cross(b-a,d-a);
    if(sgn(oa)*sgn(ob)<0&&sgn(oc)*sgn(od)<0) return 1;
    if(onseg(c,d,a)||onseg(c,d,b)||onseg(a,b,c)||onseg(a,b,d)) return 1;
    return 0;
}
ld ans[1000];
void chk(int d) {
    vector<pnt> G;
    for(auto&x:ms) G.push_back(x.fi),G.push_back(x.se);
    G.push_back(st.fi); G.push_back(st.se);
    G.push_back(ed.fi); G.push_back(ed.se);
    vector<pair<pnt,pnt>> mss=ms;
    // for(auto &t:mss) {
    //     // extend everything by eps
    //     pnt&s=t.fi,&e=t.se;
    //     pnt v=e-s; v=v/(len(v))*eps;
    //     s=s-v; e=e+v;
    // }
    set<pair<pnt,pnt>> XX;
    for(int i=0;i<G.size();++i) {
        for(int j=i+1;j<G.size();++j) {
            pnt ss=G[i],ee=G[j];
            pnt SS=lineinter(st.fi,st.se,ss,ee);
            pnt EE=lineinter(ed.fi,ed.se,ss,ee);
            for(auto S:{SS,st.fi,st.se}) for(auto E:{EE,ed.fi,ed.se}) {
                if(len2(S-E)<ans[d]) continue;
                if(XX.count({S,E})) continue;
                XX.insert({S,E});
                if(!onseg(st.fi,st.se,S)) continue;
                if(!onseg(ed.fi,ed.se,E)) continue;
                // check if it crosses all segs
                bool ok=1;
                for(auto&x:mss) if(!seginter(S,E,x.fi,x.se)) {ok=0; break;}
                if(ok) {
                    ans[d]=max(ans[d],len2(S-E));
                }
            }
        }
    }
}
void dfs(poly a,int vis) {
    for(int i=0;i<n;++i) {
        ed={a[i],a[(i+1)%n]};
        chk(__builtin_popcount(vis));
    }
    for(int i=0;i<n;++i) if(!(vis&(1<<i))) {
        ms.push_back({a[i],a[(i+1)%n]});
        auto t=rf(a,i);
        dfs(t,vis|(1<<i));
        ms.pop_back();
    }
}
poly a;
int main() {
    cin>>n;
    for(int i=0;i<n;++i) {
        int x,y; cin>>x>>y;
        a.push_back(pnt(x,y));
    }
    for(int i=0;i<n;++i) {
        st={a[i],a[(i+1)%n]};
        dfs(a,0);
    }
    ld g=ans[0];
    for(int i=0;i<=n;++i) {
        g=max(g,ans[i]);
        printf("%.10Lf\n",sqrtl(g));
    }
}