#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int M = 1 << 22;
const int inf = 1000 * 1000 * 1000 + 7;
int n, v, cnt, bound;
int a[N], f[M], g[M];
int goLeft[N][23], goRight[N][23];
vector<int> b;
struct SegTree {
  int n;
  vector<int> tree;
  SegTree(int n) : n(n), tree(4 * n, inf) {}
  void update(int pos, int val) { update(1, 0, n - 1, pos, val); }
  int go(int l, int r) { return go(1, 0, n - 1, l, r); }
  void update(int v, int tl, int tr, int pos, int val) {
    if (tl == tr) {
      tree[v] = min(tree[v], val);
      return;
    }
    int tm = (tl + tr) / 2;
    if (pos <= tm) {
      update(2 * v, tl, tm, pos, val);
    } else {
      update(2 * v + 1, tm + 1, tr, pos, val);
    }
    tree[v] = min(tree[2 * v], tree[2 * v + 1]);
  }
  int go(int v, int tl, int tr, int l, int r) {
    if (l > tr || r < tl) return inf;
    if (l <= tl && r >= tr) return tree[v];
    int tm = (tl + tr) / 2;
    return min(go(2 * v, tl, tm, l, r), go(2 * v + 1, tm + 1, tr, l, r));
  }
};
void calc() {
  for (int i = 0; i < (cnt); ++i) {
    for (int j = 0; j < (n); ++j) {
      goLeft[i][j] = j;
      if (j > 0 && a[j] - a[j - 1] <= b[i]) {
        goLeft[i][j] = goLeft[i][j - 1];
      }
    }
    for (int j = n - 1; j >= 0; --j) {
      goRight[i][j] = j;
      if (j < n - 1 && a[j + 1] - a[j] <= b[i]) {
        goRight[i][j] = goRight[i][j + 1];
      }
    }
  }
}
int go(int pos, int x, int side) {
  if (side < 0) {
    return pos >= 0 ? goLeft[x][pos] : pos;
  }
  return pos < n ? goRight[x][pos] : pos;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cin >> n >> v;
  for (int i = 0; i < (n); ++i) {
    cin >> a[i];
  }
  while (v > 0) {
    b.push_back(v);
    v /= 2;
  }
  b.push_back(0);
  cnt = (int)b.size();
  bound = (1 << cnt);
  calc();
  for (int i = 0; i < (bound); ++i) f[i] = -inf, g[i] = inf;
  f[0] = 0;
  g[0] = n - 1;
  for (int i = 0; i < (bound); ++i) {
    for (int j = 0; j < (cnt); ++j)
      if (~i & (1 << j)) {
        if (f[i] != -inf) {
          f[i ^ (1 << j)] = max(f[i ^ (1 << j)], go(f[i], j, +1) + 1);
        }
        if (g[i] != inf) {
          g[i ^ (1 << j)] = min(g[i ^ (1 << j)], go(g[i], j, -1) - 1);
        }
      }
  }
  int all = 0;
  SegTree tree(n);
  for (int mask = 0; mask < (bound); ++mask) {
    int comp = (bound - 1) ^ mask;
    int a = (mask & 1) ? (mask ^ 1) : mask;
    int b = (comp & 1) ? (comp ^ 1) : comp;
    if (f[a] != -inf && g[b] != inf) {
      if (f[a] > g[b]) {
        all = 1;
        break;
      }
      tree.update(f[a], g[b]);
    }
  }
  for (int i = 0; i < (n); ++i) {
    int lb = go(i, 0, -1);
    int rb = go(i, 0, +1);
    if (tree.go(lb, rb) <= rb) {
      cout << "Possible\n";
    } else {
      cout << "Impossible\n";
    }
  }
  return 0;
}
