#include <bits/stdc++.h>
using namespace std;
using Int = signed;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
  if (a < b) a = b;
}
struct FastIO {
  FastIO() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} fastio_beet;
signed main() {
  Int n, v;
  cin >> n >> v;
  vector<Int> x(n);
  for (Int i = 0; i < n; i++) cin >> x[i];
  vector<Int> dp;
  vector<vector<Int> > ps;
  while (v) {
    vector<Int> dp2(n, 0);
    for (Int i = 1; i < n; i++) dp2[i] = dp2[i - 1] + (x[i] - x[i - 1] > v);
    if (dp.empty()) dp = dp2;
    vector<Int> ps2;
    ps2.emplace_back(0);
    for (Int i = 1; i < n; i++)
      if (dp2[i] != dp2[i - 1]) ps2.emplace_back(i);
    ps2.emplace_back(n);
    ps.emplace_back(ps2);
    v >>= 1;
  }
  {
    vector<Int> ps2(n + 1, 0);
    iota(ps2.begin(), ps2.end(), 0);
    ps.emplace_back(ps2);
  }
  int sz = ps.size();
  vector<vector<Int> > memo(ps.size(), vector<Int>(n, -1));
  auto calc = [&](Int d, Int k) -> Int {
    if (d + 1 == sz) return 1;
    Int &res = memo[d][k];
    if (~res) return res;
    res = 0;
    vector<Int> &v = ps[d];
    vector<Int> &u = ps[d + 1];
    res = lower_bound(u.begin(), u.end(), v[k + 1]) -
          lower_bound(u.begin(), u.end(), v[k]);
    return res;
  };
  using P = pair<Int, Int>;
  Int flg;
  function<void(Int, const set<P> &)> dfs = [&](Int d, const set<P> &sp) {
    if (d == sz) return;
    Int cnt = 0;
    vector<Int> &v = ps[d];
    {
      auto latte = v.begin();
      for (auto &p : sp) {
        cnt += lower_bound(latte, v.end(), p.first) - latte;
        latte = lower_bound(latte, v.end(), p.second);
      }
      cnt += v.end() - latte - 1;
    }
    flg |= (cnt <= 1);
    if (flg) return;
    if (d + cnt > sz) return;
    vector<int> &u = ps[d + 1];
    int ncnt = u.size() - 1;
    for (auto &p : sp) {
      ncnt -= lower_bound(u.begin(), u.end(), p.second) -
              lower_bound(u.begin(), u.end(), p.first);
    }
    set<P> nsp = sp;
    {
      Int k = 0;
      for (auto &p : sp) {
        while (v[k] < p.first) {
          if (d + ncnt - calc(d, k) <= sz) {
            nsp.emplace(v[k], v[k + 1]);
            dfs(d + 1, nsp);
            nsp.erase(P(v[k], v[k + 1]));
            if (flg) return;
          }
          k++;
        }
        k = lower_bound(v.begin(), v.end(), p.second) - v.begin();
      }
      while (k + 1 < (Int)v.size()) {
        if (d + ncnt - calc(d, k) <= sz) {
          nsp.emplace(v[k], v[k + 1]);
          dfs(d + 1, nsp);
          nsp.erase(P(v[k], v[k + 1]));
          if (flg) return;
        }
        k++;
      }
    }
  };
  for (Int i = 0; i < n;) {
    Int l = i, r = *upper_bound(ps[0].begin(), ps[0].end(), l);
    set<P> sp;
    sp.emplace(l, r);
    flg = 0;
    dfs(1, sp);
    string ans = (flg ? "Possible" : "Impossible");
    Int p = i;
    while (i < n && dp[p] == dp[i]) {
      cout << ans << endl;
      i++;
    }
  }
  return 0;
}
