#include<bits/stdc++.h>
using namespace std;
typedef long double db;
const db inf=1e100;
const db eps=1e-10;
int sgn(db x)
{
    if(x>eps)return 1;
    if(x<-eps)return -1;
    return 0;
}
struct Point
{
    db x,y;
    explicit Point(db _x=0,db _y=0):x(_x),y(_y) {}
    Point operator + (const Point& t)const
    {
        return Point(x+t.x,y+t.y);
    }
    Point operator - (const Point& t)const
    {
        return Point(x-t.x,y-t.y);
    }
    Point operator * (const db& t)const
    {
        return Point(x*t,y*t);
    }
    Point operator / (const db& t)const
    {
        return Point(x/t,y/t);
    }
    db operator * (const Point& t)const
    {
        return x*t.y-y*t.x;
    }
    db operator ^ (const Point& t)const
    {
        return x*t.x+y*t.y;
    }
    db len()const
    {
        return sqrt(x*x+y*y);
    }
    Point norm()const
    {
        return *this/len();
    }
    void read()
    {
        int tx,ty;
        scanf("%d%d",&tx,&ty);
        x=tx,y=ty;
    }
};
struct Line
{
    Point s,v;
    Line() {}
    Line(const Point& _s,const Point& _v):s(_s),v(_v.norm()) {}
    pair<bool,Point> operator & (const Line &t)const
    {
        db c=v*t.v;
        if(sgn(c)==0)return make_pair(0,Point());
        return make_pair(1,s+v*(((t.s-s)*t.v)/c));
    }
};
int main()
{
    int n;
    scanf("%d",&n);
    vector<Point> p(n);
    for(int i=0; i<n; i++)
        p[i].read();
    vector<db> len;
    vector<Line> board;
    for(int i=0; i<n; i++)
    {
        len.push_back((p[(i+1)%n]-p[i]).len());
        board.emplace_back(p[i],p[(i+1)%n]-p[i]);
    }
    auto flip=[&](const Point& p,const Point& v)
    {
        return v*(p^v)*2-p;
    };
    vector<int> vis(n);
    vector<db> res(n+1);
    vector<tuple<Line,Point,int>> hit;
#ifdef LOCAL
    vector<vector<Point>> way(n+1);
#endif // LOCAL
    auto check=[&](Line ball,Point t)
    {
#ifdef LOCAL
        vector<Point> path;
        path.push_back(ball.s);
#endif // LOCAL
        db cur=0;
        for(auto& [_,__,i] : hit)
        {
            auto [ok,p]=ball&board[i];
            if(!ok)return;
            db r=(p-ball.s)^ball.v;
            if(sgn(r)<0)return;
            r=(p-board[i].s)^board[i].v;
            if(sgn(r)<0 || sgn(r-len[i])>0)return;
            cur+=(p-ball.s).len();
#ifdef LOCAL
            path.push_back(p);
#endif // LOCAL
            ball.s=p;
            ball.v=flip(ball.v,board[i].v).norm();
        }
        for(int i=(int)hit.size()-1; i>=0; i--)
        {
            const Line& e=get<0>(hit[i]);
            t=flip(t-e.s,e.v)+e.s;
        }
        cur+=(t-ball.s).len();
#ifdef LOCAL
        path.push_back(t);
        if(res[hit.size()]<cur)
            way[hit.size()]=move(path);
#endif // LOCAL
        res[hit.size()]=max(res[hit.size()],cur);
    };
    auto inter=[&](const vector<Line>& poly,const Line& l,Point& s)
    {
        bool ret=0;
        for(int i=0; i<n; i++)
        {
            auto [ok,p]=l&poly[i];
            if(!ok)continue;
            db r=(p-poly[i].s)^poly[i].v;
            if(sgn(r)<0 || sgn(r-len[i])>0)continue;
            if(!ret)s=p,ret=1;
            else if(sgn((p-s)^l.v)>0)s=p;
        }
        return ret;
    };
    auto solve=[&](const vector<Line>& poly,Point u,Point v)
    {
        if(sgn((u-v).len())==0)return;
        Point s,t;
        if(!inter(board,Line(v,u-v),s) || !inter(poly,Line(u,v-u),t))return;
        check(Line(s,v-u),t);
    };
    auto update=[&](const vector<Line>& poly)
    {
        for(auto& e : board)
            for(auto& f : poly)
                solve(poly,e.s,f.s);
        for(size_t i=0; i<hit.size(); i++)
        {
            for(auto& e : board)
            {
                solve(poly,e.s,get<0>(hit[i]).s);
                solve(poly,e.s,get<1>(hit[i]));
            }
            for(auto& f : poly)
            {
                solve(poly,get<0>(hit[i]).s,f.s);
                solve(poly,get<1>(hit[i]),f.s);
            }
            for(size_t j=i+1; j<hit.size(); j++)
            {
                solve(poly,get<0>(hit[i]).s,get<0>(hit[j]).s);
                solve(poly,get<0>(hit[i]).s,get<1>(hit[j]));
                solve(poly,get<1>(hit[i]),get<0>(hit[j]).s);
                solve(poly,get<1>(hit[i]),get<1>(hit[j]));
            }
        }
    };
    auto dfs=[&](const auto& self,vector<Line> poly)->void
    {
        update(poly);
        for(int i=0; i<n; i++)
        {
            if(vis[i])continue;
            vector<Line> tpoly(poly);
            const Line& e=poly[i];
            for(auto& f : tpoly)
            {
                f.s=flip(f.s-e.s,e.v)+e.s;
                f.v=flip(f.v,e.v).norm();
            }
            vis[i]=1;
            hit.emplace_back(e,poly[(i+1)%n].s,i);
            self(self,tpoly);
            hit.pop_back();
            vis[i]=0;
        }
    };
    dfs(dfs,board);
    for(int i=1; i<=n; i++)
    {
#ifdef LOCAL
        if(res[i]<res[i-1])
            way[i]=way[i-1];
#endif // LOCAL
        res[i]=max(res[i],res[i-1]);
    }
    for(int i=0; i<=n; i++)
    {
        printf("%.18Lf\n",res[i]);
#ifdef LOCAL
        for(size_t j=0; j<way[i].size(); j++)
        {
            if(j)printf(" -> ");
            printf("(%.3Lf, %.3Lf)",way[i][j].x,way[i][j].y);
        }
        printf("\n");
#endif // LOCAL
    }
    return 0;
}