I dont know if anyone came up with this soln but when I thought of this soln I got extremely happy and joyful. Here goes the logic: Basically we can use dfs to iterate through every node and use a dp table which holds the maximum distance of that node from the end node(n). Now the base case will be when we reach 'n' we return 1. Now for every other node we call dfs for all its adjacent nodes and return the value of that node as maximum of all the distances the adjacent node returns. At the same time we hold a child vector which stores the next node for each node. We do this in order to be able to trace the path. However, if we dont reach n we return 0. So that's the "IMPOSSIBLE" condition. So, dp[i] shows the max distance of that node from 'n'

int dfs(vector<int> adj[],int n,int node,vector<int>& dp,vector<int>& child){
    if(node==n) return dp[n]=1;       //base case

    if(dp[node]!=-1) return dp[node];   //If the value already exists

    int maxi=0;
    for(auto it:adj[node]){
       int trav = dfs(adj,n,it,dp,child);       //calling dfs for adj nodes
       int tmp = trav==0 ? 0 : 1+trav;      
       if(tmp>maxi){                  //updating the max value
         child[node]=it;             //updating the child
         maxi=tmp;
       }
    }
    return dp[node] = maxi;
}


int main(){
    int n,m;
    cin>>n>>m;
    vector<int> adj[n+1];
    for(int i=0;i<m;i++){
        int a,b;
        cin>>a>>b;
        adj[a].push_back(b);
    }
    vector<int> dp(n+1,-1);     //dp that holds max distance of every node from n
    vector<int> child(n+1,-1);  //holds the next node in the max distance path

    int val = dfs(adj,n,1,dp,child);
    if(val==0){
        cout<<"IMPOSSIBLE";       //'n' node is unreachable
    }
    else{
        cout<<val<<endl; 
           int node=1;
           while(node!=n){         //printing the path
              cout<<node<<" ";
              node=child[node];
           }
           cout<<n;
    }
}