#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &res) {
  res = 0;
  T f = 1;
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
  }
  res *= f;
}
template <class T>
void out(T x) {
  if (x < 0) {
    x = -x;
    putchar('-');
  }
  if (x >= 10) {
    out(x / 10);
  }
  putchar('0' + x % 10);
}
bool can[200005];
int x[200005], N, V, d[200005], tot, fa[200005];
int sum[20][200005];
vector<int> drawer[200005];
struct node {
  int lay, num, l, r;
  friend bool operator<(const node &a, const node &b) {
    if (a.lay != b.lay)
      return a.lay < b.lay;
    else if (a.num != b.num)
      return a.num > b.num;
    return a.l < b.l;
  }
};
set<node> S;
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void allF() {
  for (int i = 1; i <= N; ++i) {
    puts("Impossible");
  }
}
int calc(int l, int r, int d) { return sum[d][r] - sum[d][l]; }
bool dfs(int lw) {
  if (lw > tot) return false;
  if (!S.size()) return true;
  vector<int> line;
  while (1) {
    node t = *S.begin();
    if (t.lay > lw) break;
    S.erase(S.begin());
    line.clear();
    line.push_back(t.l);
    line.push_back(t.r);
    for (auto k : drawer[lw]) {
      if (k >= t.l && k <= t.r) {
        line.push_back(k);
        line.push_back(k - 1);
      }
    }
    sort(line.begin(), line.end());
    for (int i = 1; i < line.size(); i += 2) {
      int tl = line[i - 1], tr = line[i];
      for (int j = lw + 1; j <= tot + 1; ++j) {
        if (j == tot + 1 || calc(tl, tr, j)) {
          S.insert((node){j, calc(tl, tr, j), tl, tr});
          break;
        }
      }
    }
    if (tot - lw < S.size()) return false;
  }
  S.erase(S.begin());
  return dfs(lw + 1);
}
void Solve() {
  read(N);
  read(V);
  for (int i = 1; i <= N; ++i) {
    fa[i] = i;
    read(x[i]);
  }
  for (int i = 2; i <= N; ++i) {
    if (x[i] - x[i - 1] <= V) fa[getfa(i)] = getfa(i - 1);
  }
  d[++tot] = V;
  while (d[tot]) {
    ++tot;
    d[tot] = d[tot - 1] / 2;
  }
  for (int i = 2; i <= N; ++i) {
    for (int j = tot; j >= 1; --j) {
      if (d[j] >= x[i] - x[i - 1]) {
        sum[j][i] = 1;
        drawer[j].push_back(i);
        break;
      }
    }
  }
  for (int j = 1; j <= tot; ++j) {
    for (int i = 1; i <= N; ++i) {
      sum[j][i] += sum[j][i - 1];
    }
  }
  int siz = 0;
  for (int i = 1; i <= N; ++i) {
    if (fa[i] == i) {
      ++siz;
    }
  }
  if (siz - 1 > tot - 1) {
    allF();
    return;
  }
  for (int i = 1; i <= N; ++i) {
    if (fa[i] == i) {
      int l = i, r = i;
      while (getfa(r + 1) == i) ++r;
      S.clear();
      for (int k = 1; k <= N; ++k) {
        if (k >= l && k <= r) continue;
        if (fa[k] == k) {
          int r = k;
          while (getfa(r + 1) == k) ++r;
          for (int j = 1; j <= tot + 1; ++j) {
            if (j == tot + 1 || calc(k, r, j) > 0) {
              S.insert((node){j, calc(k, r, j), k, r});
              break;
            }
          }
        }
      }
      can[i] = dfs(1);
    }
  }
  for (int i = 1; i <= N; ++i) {
    if (can[getfa(i)])
      puts("Possible");
    else
      puts("Impossible");
  }
}
int main() { Solve(); }
