#include <bits/stdc++.h>
template <typename T>
void MACRO_VAR_Scan(T& t) {
  std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First& first, Rest&... rest) {
  std::cin >> first;
  MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T& t) {
  t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
  first.resize(n);
  MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T& t) {
  std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
  std::cin >> first[p];
  MACRO_VEC_ROW_Scan(p, rest...);
}
template <typename T>
inline T CHMAX(T& a, const T b) {
  return a = (a < b) ? b : a;
}
template <typename T>
inline T CHMIN(T& a, const T b) {
  return a = (a > b) ? b : a;
}
void CHECKTIME(std::function<void()> f) {
  auto start = std::chrono::system_clock::now();
  f();
  auto end = std::chrono::system_clock::now();
  auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))
                 .count();
  std::cerr << "[Time:" << res << "ns  (" << res / (1.0e9) << "s)]\n";
}
using ll = long long;
using ull = unsigned long long;
constexpr int INFINT = 1 << 30;
constexpr int INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-7;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  ;
  std::ifstream ifs("test.in");
  int n, V;
  MACRO_VAR_Scan(n, V);
  ;
  if (false) {
    std::random_device rnd;
    std::mt19937 mt(rnd());
    std::uniform_int_distribution<> rand(-1000000000, 1000000000);
    std::set<int> set;
    while (set.size() < n) set.insert(rand(mt));
    std::cout << n;
    std::cout << " ";
    std::cout << V;
    std::cout << "\n";
    ;
    for (auto x : set) {
      std::cout << x;
      std::cout << " ";
      ;
    }
    std::cout << "\n";
    ;
    return 0;
  }
  std::vector<int> x(n);
  for (auto& i : x) std::cin >> i;
  ;
  int height = 0;
  while (V >= (1 << height)) ++height;
  height += 2;
  std::vector<std::vector<int>> right(height);
  int vv = V;
  right[0].emplace_back(x[n - 1]);
  for (int h = (1); h < (height); ++h) {
    int r = n - 1;
    for (int i = (n - 1) - 1; i >= 0; --i) {
      if (x[i + 1] - x[i] > vv || i == 0) {
        right[h].emplace_back(x[r]);
        r = i;
      }
    }
    if (x[1] - x[0] > vv) right[h].emplace_back(x[0]);
    std::sort((right[h]).begin(), (right[h]).end());
    vv /= 2;
  }
  std::vector<int> c(height + 1, 0);
  for (int i = 0; i < int(height); ++i) c[i] = right[i].size();
  for (int i = 0; i < int(height - 1); ++i) c[i + 1] += c[i];
  std::rotate(c.rbegin(), c.rbegin() + 1, c.rend());
  std::vector<std::vector<int>> g(1);
  g.reserve(n * height);
  int p = 0;
  for (int h = (1); h < (height); ++h) {
    for (auto v : right[h]) {
      ++p;
      auto it =
          std::lower_bound((right[h - 1]).begin(), (right[h - 1]).end(), v);
      int par = std::distance(right[h - 1].begin(), it) + c[h - 1];
      g.emplace_back(std::vector<int>{});
      g[par].emplace_back(p);
    }
  }
  std::vector<int> v0;
  for (auto v : g[0]) v0.emplace_back(v);
  std::function<bool(std::vector<int>&, int, int)> check =
      [&](std::vector<int>& a, int pos, int rest) {
        if (rest == 0) return true;
        if (a.empty()) return true;
        std::vector<int> c;
        int asz = a.size();
        for (int i = 0; i < int(asz); ++i) {
          auto& v = g[a[i]];
          for (int j = 0; j < int(v.size()); ++j) {
            if (a[i] > v[j]) continue;
            c.emplace_back(v[j]);
          }
        }
        int csz = c.size();
        for (auto v : a) {
          if (pos != -1) v = pos;
          if (csz - g[v].size() > rest - 1) continue;
          auto ts(c);
          for (auto& to : g[v]) {
            if (v > to) continue;
            ts.erase(std::find((ts).begin(), (ts).end(), to));
          }
          ts.shrink_to_fit();
          if (check(ts, -1, rest - 1)) return true;
          if (pos != -1) break;
        }
        return false;
      };
  std::vector<std::pair<int, int>> ok;
  p = 0;
  for (auto& v : v0) {
    bool t = check(v0, v, height - 1);
    ok.emplace_back(std::pair<int, int>(right[1][p++], t));
  }
  p = 0;
  for (int i = 0; i < int(n); ++i) {
    if (x[i] <= ok[p].first) {
      std::cout << ((ok[p].second) ? "Possible" : "Impossible");
      std::cout << "\n";
      ;
    }
    if (x[i] == ok[p].first) ++p;
  }
  return 0;
}
