#include <bits/stdc++.h>
using namespace std;
int N, V;
int p[200005], d[200005];
int K, v[25];
int rgt[200005];
int bst[200005];
bool can[200005];
class Solver {
 public:
  int dst[200005];
  int lgt[200005][20];
  int dp[200005];
  Solver() {
    memset(dst, 0, sizeof(dst));
    memset(lgt, 0, sizeof(lgt));
    for (int i = 1; i < N; i++) dst[i] = d[i];
  }
  void precalc() {
    for (int i = N; i >= 1; i--)
      for (int j = 0; j <= K; j++) {
        if (dst[i] <= v[j])
          lgt[i][j] = lgt[i + 1][j] + 1;
        else
          lgt[i][j] = 1;
      }
    for (int msk = 1; msk < (1 << K); msk++) {
      for (int b = 0; b < K; b++)
        if ((1 << b) & msk) {
          int mmsk = msk ^ (1 << b);
          int pos = dp[mmsk];
          dp[msk] = max(dp[msk], pos + lgt[pos + 1][b]);
        }
    }
  }
};
void possible() { printf("Possible\n"); }
void impossible() { printf("Impossible\n"); }
int main() {
  scanf("%d%d", &N, &V);
  for (int i = 1; i <= N; i++) scanf("%d", &p[i]);
  for (int i = 1; i < N; i++) d[i] = p[i + 1] - p[i];
  K = -1;
  int aux = V;
  while (aux) {
    aux /= 2;
    v[++K] = aux;
  }
  reverse(v, v + K + 1);
  v[++K] = V;
  Solver pfx;
  reverse(d + 1, d + N);
  Solver sfx;
  reverse(d + 1, d + N);
  pfx.precalc();
  sfx.precalc();
  int mskmax = (1 << K) - 1;
  for (int msk = mskmax; msk >= 0; msk--) {
    can[pfx.dp[msk]] = 1;
    bst[msk] = max(bst[msk], sfx.dp[msk ^ mskmax]);
    int st = pfx.dp[msk];
    int dr = bst[msk];
    rgt[st] = max(rgt[st], dr);
  }
  for (int i = N - 1; i >= 0; i--) rgt[i] = max(rgt[i], rgt[i + 1]);
  for (int i = 1; i <= N; i++) {
    int st = i - 1;
    int dr = N - rgt[st] + 1;
    int posmax = i + pfx.lgt[i][K] - 1;
    if (dr - 1 <= posmax && can[st])
      for (int j = 1; j <= pfx.lgt[i][K]; j++) possible();
    else
      for (int j = 1; j <= pfx.lgt[i][K]; j++) impossible();
    i = posmax;
  }
  return 0;
}
