#include <bits/stdc++.h>
using namespace std;
using Int = long long;
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;
}
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);
  }
  vector<vector<Int> > memo(ps.size(), vector<Int>(n, -1));
  function<Int(Int, Int)> calc = [&](Int d, Int k) -> Int {
    if (d + 1 == (Int)ps.size()) return 1;
    Int &res = memo[d][k];
    if (~res) return res;
    res = 0;
    vector<Int> &v = ps[d];
    vector<Int> &u = ps[d + 1];
    Int x = lower_bound(u.begin(), u.end(), v[k]) - u.begin();
    Int tmp = 0;
    while (u[x] < v[k + 1]) {
      res += calc(d + 1, x);
      chmax(tmp, calc(d + 1, x) - 1);
      x++;
    }
    res -= tmp;
    return res;
  };
  using P = pair<Int, Int>;
  Int flg;
  function<void(Int, const set<P> &)> dfs = [&](Int d, const set<P> &sp) {
    if (d == (Int)ps.size()) 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 (0) {
      cout << d << ":" << cnt << "::" << (Int)ps.size() << endl;
      for (auto p : sp) cout << p.first << " " << p.second << endl;
      cout << endl;
    }
    if (d + cnt > (Int)ps.size()) return;
    Int ncnt = 0;
    {
      Int k = 0;
      for (auto &p : sp) {
        while (v[k] < p.first) {
          ncnt += calc(d, k);
          k++;
        }
        k = lower_bound(v.begin(), v.end(), p.second) - v.begin();
      }
      while (k + 1 < (Int)v.size()) {
        ncnt += calc(d, k);
        k++;
      }
    }
    set<P> nsp = sp;
    {
      Int k = 0;
      for (auto &p : sp) {
        while (v[k] < p.first) {
          if (d + ncnt - calc(d, k) <= (Int)ps.size()) {
            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) <= (Int)ps.size()) {
          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;
}
