import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;
     
void main() {
    auto input = readln.split.map!(to!int);
    auto N = input[0];
    auto V = input[1];
    auto X = readln.split.map!(to!long).array;

    Tuple!(int, int, int, int)[][] segments;


    while (true) {
        Tuple!(int, int, int, int)[] tmp;
        long prev = - (1L << 59);
        foreach (i; 0..N) {
            if (X[i] - prev > V)
                tmp ~= tuple(i, i, 1, i);
            else
                tmp[$-1][1] = i;
            prev = X[i];
        }
        segments ~= tmp;
        if (V == 0)
            break;
        V /= 2;
    }

    int logV = segments.length.to!int;

    foreach (i; 0..logV-1) {
        int k = 0;
        foreach (j; 0..segments[i].length) {
            int old_k = k;
            segments[i][j][3] = old_k;
            while (k < segments[i+1].length && segments[i+1][k][1] <= segments[i][j][1])
                k++;
            segments[i][j][2] = k - old_k;
        }
    } 
    

    if (segments[0].length > logV) {
        N.iota.each!(_ => "Impossible".writeln);
        return;
    }

    debug {segments.each!writeln;}
    auto ans = new bool[](N);

    bool solve(int start) {
        Tuple!(int, int, int, int)[] q;
        foreach (s; segments[0])
            if (s[0] != segments[0][start][0])
                q ~= s;
        q.sort!"a[2] < b[2]"();
        
        foreach (i; 1..logV) {
            int rest = logV - i;
            
            if (q.map!(a => a[2]).sum > rest)
                return false;
            
            Tuple!(int, int, int, int)[] r;
            foreach (s; q)
                foreach (j; s[3]..s[3]+s[2])
                    r ~= segments[i][j];

            if (r.length == 0)
                return true;

            r.sort!"a[2] < b[2]"();
            r.popBack;
            q = r;
        }

        return q.length == 0;
    }
    
    foreach (start; 0..segments[0].length) {
        bool ok = solve(start.to!int);
        foreach (i; segments[0][start][0]..segments[0][start][1]+1)
            ans[i] = ok;
    }

    ans.map!(a => a ? "Possible" : "Impossible").each!writeln;
}
