Sunake is in the form of a polygonal line consisting of n vertices (without self-intersection). First, Sunake-kun's i-th vertex is at (xi, yi). You can move continuously by translating or rotating, but you cannot deform (change the length of the polygonal line or the angle between the two line segments). y = 0 is the wall, and there is a small hole at (0, 0). Determine if you can move through this hole so that the whole thing meets y <0.

Constraints

* 2 ≤ n ≤ 1000
* 0 ≤ xi ≤ 109
* 1 ≤ yi ≤ 109
* Lines do not have self-intersections
* None of the three points are on the same straight line
* (xi, yi) ≠ (xi + 1, yi + 1)
* All inputs are integers

Input


n
x1 y1
.. ..
xn yn


Output

Output "Possible" if you can move through the hole, and "Impossible" if you can't.

Examples

Input

4
0 1
1 1
1 2
2 2


Output

Possible


Input

11
63 106
87 143
102 132
115 169
74 145
41 177
56 130
28 141
19 124
0 156
22 183


Output

Impossible
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 998244353;
const ll INF = (1e+18) + 7;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-6;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;

ll mod_pow(ll a, ll n) {
	ll res = 1;
	while (n) {
		if (n & 1)res = res * a%mod;
		a = a * a%mod; n >>= 1;
	}
	return res;
}

struct modint {
	ll n;
	modint() :n(0) { ; }
	modint(ll m) :n(m) {
		if (n >= mod)n %= mod;
		else if (n < 0)n = (n%mod + mod) % mod;
	}
	operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
	if (n == 0)return modint(1);
	modint res = (a*a) ^ (n / 2);
	if (n % 2)res = res * a;
	return res;
}

ll inv(ll a, ll p) {
	return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }

const int max_n = 500;
modint fact[max_n], factinv[max_n];
void init_f() {
	fact[0] = modint(1);
	for (int i = 0; i < max_n - 1; i++) {
		fact[i + 1] = fact[i] * modint(i + 1);
	}
	factinv[max_n - 1] = modint(1) / fact[max_n - 1];
	for (int i = max_n - 2; i >= 0; i--) {
		factinv[i] = factinv[i + 1] * modint(i + 1);
	}
}
modint comb(int a, int b) {
	if (a < 0 || b < 0 || a < b)return 0;
	return fact[a] * factinv[b] * factinv[a - b];
}

int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };


using speP = pair<ld, int>;

struct edge {
	int to; ld cost;
};
ld dist(P a, P b) {
	ld dx = b.first - a.first;
	ld dy = b.second - a.second;
	return sqrt(pow(dx, 2) + pow(dy, 2));
}

bool ison(P a, P l, P r) {
	ld cl = dist(a, l);
	ld cr = dist(a, r);
	ld cm = dist(l, r);
	return abs(cl + cr - cm) < eps;
}

int ban(P a, P b, P l, P r) {
	if (!ison(l, a, b))swap(l, r);
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = r.first - l.first;
	int dy2 = r.second - l.second;
	int z = dx1 * dx2 + dy1 * dy2;
	if (z == 0)return 3;
	if (z > 0)return 1;
	if (z < 0)return 2;
}
int n;
ld x[1000], y[1000];
ld tx[1000], ty[1000];
ld td[1000];

ld cr[1000];
void solve() {
	cin >> n;
	rep(i, n) {
		cin >> x[i] >> y[i];
	}
	rep(i, n - 1) {
		tx[i] = abs(x[i + 1] - x[i]);
		ty[i] = abs(y[i + 1] - y[i]);
		td[i] = sqrt(pow(tx[i], 2) + pow(ty[i], 2));
	}
	rep1(i, n - 2) {
		ld dx1 = x[i] - x[i - 1];
		ld dy1 = y[i] - y[i - 1];
		ld dx2 = x[i + 1] - x[i];
		ld dy2 = y[i + 1] - y[i];
		ld u = dx1 * dy2 - dy1 * dx2;
		ld dif = dx1 * dx2 + dy1 * dy2;
		ld r1 = sqrt(pow(dx1, 2) + pow(dy1, 2));
		ld r2 = sqrt(pow(dx2, 2) + pow(dy2, 2));
		dif = acos(dif / (r1*r2));
		if (u > 0) {
			cr[i] = dif;
		}
		else {
			cr[i] = -dif;
		}
	}
	bool ans = true;
	rep(i, n - 1) {
		ld le = 0, ri = 0;
		ld cx = td[i], cy = 0;
		ld r = 0;
		bool f = true;
		ld z = 0;
		for (int j = i + 1; j < n - 1; j++) {
			r += cr[j];
			ld nx = cx + td[j] * cos(r);
			ld ny = cy + td[j] * sin(r);

			ld u = cx * ny - cy * nx;
			ld dif = cx * nx + cy * ny;
			ld r1 = sqrt(pow(cx, 2) + pow(cy, 2));
			ld r2 = sqrt(pow(nx, 2) + pow(ny, 2));
			dif = acos(dif / (r1*r2));
			if (u < 0) {
				z -= dif;
			}
			else {
				z += dif;
			}
			le = min(le, z);
			ri = max(ri, z);

			cx = nx, cy = ny;
		}
		if (ri - le >= pi) {
			//cout << "ar" << le<<" "<<ri<<endl;
			ans = false; break;
		}
		if (i == 0)continue;
		ld ss = 0;
		ss = -cr[i];
		//cout << cr[i] << " " << ss << endl;
		z = ss; r = ss;
		cx = td[i - 1] * cos(r), cy = td[i - 1]*sin(r);
		//if (i == 2)cout << "!!! " << atan2(cy, cx) << " " << z << endl;
		ld le2 = ss, ri2 = ss;
		for (int j = i - 2; j >= 0; j--) {
			r -= cr[j+1];
			ld nx = cx + td[j] * cos(r);
			ld ny = cy + td[j] * sin(r);

			ld u = cx * ny - cy * nx;
			ld dif = cx * nx + cy * ny;
			ld r1 = sqrt(pow(cx, 2) + pow(cy, 2));
			ld r2 = sqrt(pow(nx, 2) + pow(ny, 2));
			dif = acos(dif / (r1*r2));
			//if (i == 2)cout << "!! " << atan2(cy,cx)<<" "<<z << endl;
			if (u < 0) {
				z -= dif;
			}
			else {
				z += dif;
			}
			le2 = min(le2, z);
			ri2 = max(ri2, z);

			cx = nx, cy = ny;
		}
		if (ri2 - le2 >= pi) {
			//cout << "ar" << endl;
			ans = false; break;
		}
		le2 -= pi; ri2 -= pi;
		while (le2 <0)le2 += 2 * pi;
		while (ri2 < 0)ri2 += 2 * pi;
		while (le2 >= 2 * pi)le2 -= 2 * pi;
		while (ri2 >= 2 * pi)ri2 -= 2 * pi;
		vector<speP> v;
		v.push_back({ le,0 });
		v.push_back({ ri,1 });
		v.push_back({ le2,2 });
		v.push_back({ ri2,3 });
		sort(all(v));
		vector<int> ids;
		rep(j, 4)ids.push_back(v[j].second);
		if (ids == vec{0, 1, 2, 3} || ids == vec{1, 2, 3, 0}) {
			//
		}
		else {
			//cout << "?? " << i << " " << le << " " << ri << " " << le2 << " " << ri2 << endl;
			ans = false; break;
		}
	}
	if (ans) {
		cout << "Possible" << endl;
	}
	else {
		cout << "Impossible" << endl;
	}
	//rep(i, 4)cout << cr[i] << endl;
}


signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(10);
	//init_f(); init();
	//int t; cin >> t; rep(i, t)solve();
	//while (cin >> n, n)solve();
	solve();
	stop
		return 0;
}
