#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <utility>
#include <cstdlib>
#include <memory>
#include <queue>
#include <cassert>
#include <cmath>
#include <ctime>
#include <complex>
#include <bitset>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <numeric>

using namespace std;

#define ws ws_____________________
#define y1 y1_____________________
#define y0 y0_____________________
#define left left_________________
#define right right_______________
#define next next_________________
#define prev prev_________________
#define hash hash_________________

#define pb push_back
#define fst first
#define snd second
#define mp make_pair 
#define sz(C) ((int) (C).size())
#define forn(i, n) for (int i = 0; i < int(n); ++i)
#define ford(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define all(C) begin(C), end(C)

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vii;
typedef long double ld;
typedef complex<double> cd;

#ifdef LOCAL
#define eprintf(args...) fprintf(stderr, args), fflush(stderr)
#else
#define eprintf(...) ;
#endif

#define FILE_NAME "a"

int n, V;
vi xs;

bool read() {
	if  (scanf("%d%d", &n, &V) < 2) {
		return 0;
	}
	xs.resize(n);
	forn(i, n) {
		scanf("%d", &xs[i]);
	}
	return 1;
}

vector<vii> segs;
vi Vs;

vii getSegs(const int v) {
	vii s;
	forn(i, sz(xs)) {
		if  (s.empty()) {
			s.pb(mp(i, i));
		} else if  (xs[i] - xs[s.back().snd] <= v) {
			s.back().snd = i;
		} else {
			s.pb(mp(i, i));
		}
	}
	return s;
}

inline bool bit(int mask, int i) {
	return (mask >> i) & 1;
}

vi calcDp(const vector<vii>& segs) {
	vi dp(1 << sz(segs), 0);
	queue<int> q;
	q.push(0);
	while (!q.empty()) {
		const int mask = q.front();
		q.pop();

		forn(i, sz(segs)) {
			if  (!bit(mask, i)) {
				const int nmask = mask ^ (1 << i);
				int ptr = lower_bound(all(segs[i]), mp(0, dp[mask]), [](const pii& a, const pii& b) { return a.snd < b.snd; }) - segs[i].begin();
				int ndp = dp[mask];
				if  (ptr < sz(segs[i])) {
					ndp = segs[i][ptr].snd + 1;
				}
				if  (dp[nmask] < ndp) {
					dp[nmask] = ndp;
					q.push(nmask);
				}
			}
		}
	}
	return dp;
}

void solve() {
	Vs.clear();
	segs.clear();

	while (V) {
		Vs.pb(V);
		V /= 2;
	}
	Vs.pb(0);

	for (int v : Vs) {
		segs.pb(getSegs(v));
	}

	eprintf("segs:\n");
	forn(i, sz(segs)) {
		eprintf("%d: ", i);
		forn(j, sz(segs[i])) {
			eprintf("[%d, %d] ", segs[i][j].fst, segs[i][j].snd);
		}
		eprintf("\n");
	}

	vi dp_pref = calcDp(segs);

	for (auto& s : segs) {
		reverse(all(s));
		for (auto& seg : s) {
			swap(seg.fst, seg.snd);
			seg.fst = n - 1 - seg.fst;
			seg.snd = n - 1 - seg.snd;
		}
	}
	vi dp_suff = calcDp(segs);
	forn(mask, sz(dp_suff)) {
		dp_suff[mask] = n - dp_suff[mask] - 1;
	}
	for (auto& s : segs) {
		reverse(all(s));
		for (auto& seg : s) {
			swap(seg.fst, seg.snd);
			seg.fst = n - 1 - seg.fst;
			seg.snd = n - 1 - seg.snd;
		}
	}

	const int full = (1 << sz(segs)) - 1;
	vi ok(n, 0);
	if  (dp_pref[full ^ (1 << 0)] == n) {
		eprintf("ALL OK\n");
		ok = vi(n, 1);
	} else {
		forn(mask, 1 << sz(segs)) {
			if  (bit(mask, 0)) {
				continue;
			}

			int ptr = lower_bound(all(segs[0]), mp(0, dp_pref[mask]), [](const pii& a, const pii& b) { return a.snd < b.snd; }) - segs[0].begin();
			assert(ptr < sz(segs[0]));

			const int end_id = segs[0][ptr].snd;
			const int inv_mask = full ^ mask ^ (1 << 0);
			if  (dp_suff[inv_mask] <= end_id) {
				int l, r;
				tie(l, r) = segs[0][ptr];
				if  (!ok[l]) {
					for (int i = l; i <= r; ++i) {
						ok[i] = 1;
					}
				}
			}
		}
	}

	forn(i, n) {
		printf("%s\n", ok[i] ? "Possible" : "Impossible");
	}
	printf("\n");
}

int main() {
#ifdef LOCAL
	freopen(FILE_NAME ".in", "r", stdin);
	// freopen(FILE_NAME ".out", "w", stdout);
#endif

	while (read()) {
		solve();
	}

#ifdef LOCAL
	eprintf("Time: %.10f\n", (double) clock() / CLOCKS_PER_SEC);
#endif
	return 0;
}


Measured memory_bytes: 11120