#include <fstream>
#include <stack>

class Maze{
private:
    enum direction {LEFT,DOWN,RIGHT,UP};


    int* fromUp=new int[3]{LEFT, RIGHT, UP};
    int* fromDown=new int[3]{LEFT, DOWN, RIGHT};
    int* fromLeft=new int[3]{LEFT, DOWN, UP};
    int* fromRight=new int[3]{DOWN, RIGHT, UP};

    int n;
    int m;
    int **maze;

    //    int* availDir;

public:
    Maze(){
    }
    void readMaze(std::ifstream& fin){
        fin>>n;
        fin>>m;
        //init maze
        maze=new int*[n];
        for(int i=0;i<n;i++){
            maze[i]=new int[m];
        }
        //fill default maze
        char t;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                fin>>t;
                maze[i][j]=t-'0';
            }
        }
    }

    bool step(std::stack<std::pair<int, int>>& route_stack,int direction){
        int dx,dy;
        switch (direction) {
            case UP:
                dx=-1;
                dy=0;
                break;
            case DOWN:
                dx=1;
                dy=0;
                break;
            case LEFT:
                dx=0;
                dy=-1;
                break;
            case RIGHT:
                dx=0;
                dy=1;
                break;
            default:
                dx=n;
                dy=m;
                break;
        }
        std::pair<int, int> next=std::make_pair(route_stack.top().first+dx, route_stack.top().second+dy);
        if(isOut(next)){
            return false;
        }
        route_stack.push(next);
        maze[route_stack.top().first][route_stack.top().second]=2;
        if(route_stack.top().first==n-1){
            return true;
        }
        int* availDir;
        switch (direction) {
            case UP:
                availDir=fromUp;
                break;
            case DOWN:
                availDir=fromDown;
                break;
            case LEFT:
                availDir=fromLeft;
                break;
            case RIGHT:
                availDir=fromRight;
                break;
            default:
                availDir=NULL;
                break;
        }
        for(int i=0;i<3;i++){
            if(step(route_stack, availDir[i])){
                return true;
            }
        }
        maze[route_stack.top().first][route_stack.top().second] = 0;
        route_stack.pop();
        return false;
    }
    bool isOut(const std::pair<int, int>& point){
        return (point.first<0 || point.second<0 || point.first>=n || point.second>=m || maze[point.first][point.second]!=0);
    }
    bool getAnswer(){
        //algorithm
        if(n==1){
            for(int i=0;i<m;i++){
                if(maze[0][i]==0){
                    return true;
                }
            }
            return false;
        }
        else{
            bool answer=true;
            for(int i=0;i<m;i++){
                if(maze[0][i]==0){
                    std::stack<std::pair<int, int>> route_stack;
                    maze[0][i]=2;
                    route_stack.push(std::make_pair(0, i));
                    if(!step(route_stack, DOWN)){
                        answer= false;
                        break;
                    }
                }
            }
            return answer;
        }
    }
    void printAnswer(std::ofstream& fout){
        if(getAnswer()==false){
            fout<<"Impossible\n";
        } else{
            fout<<"Possible\n";
        }
        //        for(int i=0;i<n;i++){
        //            for(int j=0;j<m;j++){
        //                fout<<maze[i][j];
        //            }
        //            fout<<"\n";
        //        }
    }
};

int main(int argc, const char * argv[]) {
    std::ifstream fin("in.txt");
    std::ofstream fout("out.txt");
    Maze mz;
    mz.readMaze(fin);
    mz.printAnswer(fout);
    return 0;
}