#include <bits/stdc++.h>
using namespace std;

const int INF = 1012345678;

int A[200005];

int S[20];
int sizeS = 0;

int R[20][200005];
int L[20][200005];
bool boleh[200005];
int minPos[200005]; // for each dpL[something] = i, the smallest possible value of dpR[not of the something]
// 'something' is a bitmask

int minPos2[200005]; // for each dpL[something] >= i, the smallest possible value of dpR[not of the something]
// 'something' is a bitmask

/* dpL[i] = maximum index from the beginning that can be covered by the intervals
corresponding to a subset i of intervals from S
dpR[i] is defined similarly, just that the prefix becomes the suffix.
*/
int dpL[(1<<19)+5];
int dpR[(1<<19)+5];


int N, V;
int main(){
    scanf("%d%d", &N, &V);

    for(int i = 1; i <= N; i ++){
        scanf("%d", &A[i]);
    }

    int temp = V;
    while(true){
        S[sizeS ++] = temp;
        if(temp == 0){break;}
        temp >>= 1;
    }
    reverse(S, S+sizeS);
    for(int i = 0; i < sizeS; i++){
        //printf("S[%d]=%d\n", i, S[i]);
    }

    // S is sorted in decreasing order

    // R[i][j] is the 1-indexed right-most position reachable using move distances <= S[i] from position j
    for(int i = 0; i < sizeS; i ++){
        R[i][N] = N;
        L[i][1] = 1;
        for(int j = 2; j <= N; j ++){
            if(A[j]-A[j-1] <= S[i]){
                L[i][j] = L[i][j-1];
            }else{
                L[i][j] = j;
            }
        }

        for(int j = N-1; j >= 1; j --){
            if(A[j+1]-A[j] <= S[i]){
                // can reach j+1, hence can reach positions up to R[i][j+1]
                R[i][j] = R[i][j+1];
            }else{
                // j and j+1 disconnected
                R[i][j] = j;
            }
        }
    }

    for(int i = 0; i < (1<<sizeS); i ++){
        dpL[i] = 0;
        dpR[i] = N+1;

        // Consider the last S[j] used to construct the interval
        for(int j = 0; j < sizeS; j ++){
            if(i&(1<<j)){
                // Bit j is set in i.
                int k = i^(1<<j);

                // clearing bit results in an index lesser than the original index => already processed
                dpL[i] = max(dpL[i], R[j][min(dpL[k]+1, N)]);
                // dpL[k]+1 is first index impossible to be covered by all the previous intervals

                dpR[i] = min(dpR[i], L[j][max(dpR[k]-1, 1)]);
            }
        }
    }

    for(int i = 0; i <= N; i ++){
        minPos[i] = INF;
    }

    // Now check whether it is possible to reach all the oases.
    for(int i = 0; i < (1<<(sizeS-1)); i ++){
        int j = (1<<(sizeS-1))-1-i;

        int l = dpL[i];
        int r = dpR[j];
        //printf("dpL[%d]=%d; dpR[%d]=%d\n", i, l, j, r);
        minPos[l] = min(minPos[l], r);
    }

    minPos2[N] = minPos[N];
    for(int i = N-1; i >= 0; i --){
        minPos2[i] = min(minPos2[i+1], minPos[i]);
        //printf("minPos[%d]=%d\n", i, minPos[i]);
    }

    //init();
    for(int i = 1; i <= N; i ++){
        int l = L[sizeS-1][i];
        int r = R[sizeS-1][i];

        //printf("i=%d l=%d r=%d\n", i, l, r);

        boleh[i] = minPos2[l-1] <= r+1;
        if(boleh[i]){
            printf("Possible\n");
        }else{
            printf("Impossible\n");
        }
    }

    return 0;
}


Measured memory_bytes: 40064