#include <iostream>
#include <cmath>
#include <vector>
#include <initializer_list>

struct point
{
	double x, y;
	point(double x, double y) : x(x), y(y) {} // emplace_back() requires this constructor, at least, for g++ 4.5
};

inline double square(double d)
{
	return d*d;
}

// Calculate coordinate(s) of crossing point(s) between 2 circles
// (x-x1)^2 + (y-y1)^2 = r1^2 and (x-x2)^2 + (y-y2)^2 = r2^2 
std::vector<point> cross_circle(double x1, double y1, double r1, double x2, double y2, double r2)
{
	double la = 2 * (x1 - x2), lb = 2 * (y1 -y2), lc = r1*r1 - r2*r2 - x1*x1 + x2*x2 - y1*y1 + y2*y2;
	std::vector<point> result;
	if(la == 0) {
		if(lb == 0) {
			if(lc == 0) throw 1; // any point in whole plane can be root.
		} else {
			double Y = - lc / lb;
			double D = r1*r1 - (Y - y1)*(Y- y1);
			if(D > 0) {
				result.emplace_back(x1 + sqrt(D), Y);
				result.emplace_back(x1 - sqrt(D), Y);
			} else if(D == 0) {
				result.emplace_back(x1, Y);
			}
		}
	} else {
		double A = - lb / la, B = - lc / la;
		double D = square(2*A*(B-x1)-2*y1)-4*(A*A+1)*((B-x1)*(B-x1)+y1*y1-r1*r1);
		if(D > 0) {
			result.emplace_back(A*(-2*A*(B-x1)+2*y1+sqrt(D))/2/(1+A*A)+B, (-2*A*(B-x1)+2*y1+sqrt(D))/2/(1+A*A));
			result.emplace_back(A*(-2*A*(B-x1)+2*y1-sqrt(D))/2/(1+A*A)+B, (-2*A*(B-x1)+2*y1-sqrt(D))/2/(1+A*A));
		} else if(D == 0) {
			result.emplace_back(A*(-2*A*(B-x1)+2*y1)/2/(1+A*A)+B, (-2*A*(B-x1)+2*y1)/2/(1+A*A));
		}
	}
	return result;
}

const double THRESHOLD = 0.000001;

inline double distance2(const point &p1, const point &p2)
{
	return square(p1.x - p2.x) + square(p1.y - p2.y);
}


inline double distance(const point &p1, const point &p2)
{
	return std::sqrt(distance2(p1, p2));
}

inline bool near(const point& p1, const point &p2)
{
	return distance2(p1, p2) <= square(THRESHOLD);
}

bool check(int n, double dist, const std::vector<point> &v)
{
	for(std::size_t i = 0; i != v.size(); ++i) {
		if(distance2({ 0, 0 }, v[i]) > 1 + THRESHOLD) return false; // Not in circle
		for(std::size_t j = i + 1; j < v.size(); ++j) {
			if(distance2(v[i], v[j]) + THRESHOLD < square(dist)) return false; // Distance unsatisfactory
		}
	}
	return true;
}

bool process(int n, int level, double dist, std::vector<point> &v)
{
	if(level == n) {
		return check(n, dist, v);
	} else if(level == 0) {
		v.clear();
		v.emplace_back(-1, 0);
		return process(n, level+1, dist, v);
	} else {
		std::vector<point> candidate;
		auto is_new = [&](const point &p)->bool {
			if(distance2({ 0, 0 }, p) > 1 + THRESHOLD) return false; // Not in circle
			for(int j = 0; j < level - 1; ++j) {
				if(near(p, v[j])) return false; // Duplicate
				if(distance2(p, v[j]) + THRESHOLD < square(dist)) return false; // Distance unsatisfactory
			}
			for(std::size_t j = 0; j != candidate.size(); ++j) {
				if(near(p, candidate[j])) return false; // Duplicate in candidates
			}
			return true;
		};
		try {
			auto v1 = cross_circle(0, 0, 1, v[level-1].x, v[level-1].y, dist);
			if(v1.size() > 1 && level == 1) v1.pop_back(); // vertically symmetric
			for(std::size_t i = 0; i != v1.size(); ++i) {
				if(is_new(v1[i])) candidate.push_back(v1[i]);
			}
		} catch(int) {
			// When v[level-1].x == v[level-1].y == 0 && dist == 1, exception thrown
			// We can simply ignore because candidates are selected by the below criteria
		}
		for(int i = 0; i < level - 1; ++i) {
			auto v2 = cross_circle(v[i].x, v[i].y, dist, v[level-1].x, v[level-1].y, dist);
			for(std::size_t j = 0; j != v2.size(); ++j) {
				if(is_new(v2[j])) candidate.push_back(v2[j]);
			}
		}
		for(std::size_t i = 0; i != candidate.size(); ++i) {
			v.push_back(candidate[i]);
			if(process(n, level+1, dist, v)) return true;
			v.pop_back();
		}
		return false;
	}
}

int main(void)
{
	int n; std::cin >> n;
	std::vector<point> result;
	double l = THRESHOLD, r = 2.1, t;
	for(int i=0;i<30;++i) {
		t = (l+r)/2;
		if(process(n, 0, t, result)) {
			l = t;
		} else {
			r = t;
		}
	}
	if(process(n, 0, l, result)) {
		std::cout << "POSSIBLE: " << l << std::endl;
		for(std::size_t i = 0; i != result.size(); ++i) {
			std::cout << result[i].x << ',' << result[i].y << std::endl;
		}
	} else {
		std::cout << "IMPOSSIBLE" << std::endl;
	}
	return 0;
}