#include <bits/stdc++.h>

struct vec
{
	double x, y;

	double len() const { return hypot(x, y); }
	double len2() const;
};
vec operator+(const vec& x, const vec &y) { return {x.x + y.x, x.y + y.y}; }
vec operator-(const vec& x, const vec &y) { return {x.x - y.x, x.y - y.y}; }
double operator*(const vec& x, const vec &y) { return x.x * y.x + x.y * y.y; }
vec operator*(const vec& x, const double &y) { return {x.x * y, x.y * y}; }
vec operator/(const vec& x, const double &y) { return {x.x / y, x.y / y}; }
double det(const vec& x, const vec &y) { return x.x * y.y - x.y * y.x; }

double wedge(const vec& x, const vec &y, const vec &z) { return det(y - x, z - x); }
double area(const vec& x, const vec &y, const vec &z) { return wedge(x, y, z) / 2; }

double vec::len2() const { return *this * *this; }
bool operator==(const vec& x, const vec &y) { return (x - y).len2() < 1E-14; }
bool operator!=(const vec& x, const vec &y) { return (x - y).len2() >= 1E-14; }

vec proj(const vec& dir, const vec &v) { return dir * (dir * v) / dir.len2(); }
vec proj(const vec& x, const vec& y, const vec &p) { return x + proj(y - x, p - x); }
vec refl(const vec& x, const vec& y, const vec &p) { return proj(x, y, p) * 2 - p; }
bool sameray(const vec& x, const vec& y)
{
	return std::abs(det(x, y)) <= 1E-10 && x * y >= 0;
}
bool sbtn(const vec& x, const vec& y, const vec &z)
{
	if (sameray(x, y) || sameray(y, z))
		return false;
	if (det(x, y) < -1E-10 && det(y, z) < -1E-10)
		return false;
	if (det(x, y) < -1E-10 || det(y, z) < -1E-10)
		return det(x, z) < 0;
	return true;
}

bool projon(const vec& dir, const vec &v)
{
	double x = dir * v;
	return 1E-10 < x && x < dir.len2() - 1E-10;
}
bool projon(const vec& x, const vec& y, const vec &p) { return projon(y - x, p - x); }

bool onray(const vec& dir, const vec &v)
{
	auto p = proj(dir, v);
	if (p != v)
		return false;
	return -1E-10 < dir * v;
}
bool onray(const vec& x, const vec& y, const vec &p)
{
	return onray(y - x, p - x);
}

double dist(const vec& x, const vec& y) { return (y - x).len(); }

std::ostream &operator<<(std::ostream &os, const vec &v)
{
	return os << "(" << v.x << ", " << v.y << ")";
}

struct v3
{
	double x, y, z;
	v3(vec v) { x = v.x, y = v.y, z = 1; }
	v3() {} 

	vec norm()
	{
		return {x / z, y / z};
	}
};
v3 cross(const v3 &a, const v3 &b)
{
	v3 res;
	res.x = a.y * b.z - a.z * b.y;
	res.y = a.z * b.x - a.x * b.z;
	res.z = a.x * b.y - a.y * b.x;
	return res;
}

std::pair<bool, vec> inter(const vec& p1, const vec& p2, const vec& q1, const vec& q2)
{
	v3 l1 = cross(v3(p1), v3(p2));
	v3 l2 = cross(v3(q1), v3(q2));
	v3 res = cross(l1, l2);
	if (std::abs(res.z) < 1E-10)
		return {false, {}};
	return {true, res.norm()};
}

vec getpt(const std::vector<vec> &pts, int i)
{
	i %= int(pts.size());
	if (i < 0)
		i += pts.size();
	return pts[i];
}

std::pair<vec, vec> edge(const std::vector<vec> &pts, int i)
{
	return {getpt(pts, i), getpt(pts, i + 1)};
}

double Ans[] = {0, 0, 0, 0, 0, 0, 0};
bool vis[7] = {false, false, false, false, false, false, false};
int en[7];

std::vector<vec> poly[7];

int N;

int chk(int i, int j)
{
	j %= N;
	if (j < 0)
		j += N;
	if (en[i] != -1 && j == en[i])
		return 1;
	if (i != 0 && j == en[i - 1])
		return -1;
	return 0;
}

vec pred(int i, int j);
vec succ(int i, int j);

vec pred(int i, int j)
{
	int x = chk(i, j - 1);
	return x == 0 ? getpt(poly[i], j - 1) : succ(i + x, j);
}

vec succ(int i, int j)
{
	int x = chk(i, j);
	return x == 0 ? getpt(poly[i], j + 1) : pred(i + x, j);
}

void calc1(int r, vec x, vec y)
{
	// std::cout << "!! " << r << ' ' << N << std::endl;
	// std::cout << x << ' ' << y << std::endl;
	// for (int i = 0; i <= r; ++i)
	// {
	// 	for (int j = 0; j < N; ++j)
	// 		std::cout << poly[i][j] << ' ';
	// 	std::cout << std::endl;
	// }
	
	double res = 1E9;
	for (int i = 0; i <= r; ++i)
		for (int j = 0; j < N; ++j)
			if (chk(i, j) == 0)
			{
				auto [q1, q2] = edge(poly[i], j);
				auto [f, p] = inter(x, y, q1, q2);
				if (f && projon(q1, q2, p))
					res = std::min(res, dist(x, p));
			}
	for (int i = 0; i <= r; ++i)
		for (int j = 0; j < N; ++j)
			if (onray(x, y, poly[i][j]))
			{
				vec q0 = pred(i, j), q1 = poly[i][j], q2 = succ(i, j);
				// std::cout << "!! " << q0 << ' ' << q1 << ' ' << q2 << std::endl;
				if (i & 1 ? sbtn(q2 - q1, y - x, q0 - q1) : sbtn(q0 - q1, y - x, q2 - q1))
					res = std::min(res, dist(x, q1));
			}
	assert(res < 1E8);
	// std::cout << res << std::endl;
	// std::cout << std::endl;
	Ans[r] = std::max(Ans[r], res);
}

void calc(int r)
{
	for (int i = 0; i != N; ++i)
	{
		vec pt = poly[0][i];
		for (int jr = 0; jr <= r; ++jr)
		{
			for (int j = 0; j < N; ++j)
			{
				vec y = poly[jr][j];
				if (pt == y)
					break;
				calc1(r, pt, y);
			}
		}
	}
}

void dfs(int r)
{
	en[r] = -1;
	calc(r);
	for (int i = 0; i != N; ++i)
		if (!vis[i])
		{
			en[r] = i;
			vis[i] = true;
			auto [p1, p2] = edge(poly[r], i);
			for (int i = 0; i != N; ++i)
				poly[r + 1][i] = refl(p1, p2, poly[r][i]);
			dfs(r + 1);
			vis[i] = false;
		}
	en[r] = -1;
}

int main()
{
	std::cin >> N;
	for (int i = 0; i != 7; ++i)
		poly[i].resize(N);
	for (auto &pt : poly[0])
		std::cin >> pt.x >> pt.y;
	dfs(0);
	for (int i = 0; i <= N; ++i)
		printf("%.14lf\n", Ans[i]);
}