You've got a undirected graph G, consisting of n nodes. We will consider the nodes of the graph indexed by integers from 1 to n. We know that each node of graph G is connected by edges with at least k other nodes of this graph. Your task is to find in the given graph a simple cycle of length of at least k + 1.

A simple cycle of length d (d > 1) in graph G is a sequence of distinct graph nodes v1, v2, ..., vd such, that nodes v1 and vd are connected by an edge of the graph, also for any integer i (1 ≤ i < d) nodes vi and vi + 1 are connected by an edge of the graph.

Input

The first line contains three integers n, m, k (3 ≤ n, m ≤ 105; 2 ≤ k ≤ n - 1) — the number of the nodes of the graph, the number of the graph's edges and the lower limit on the degree of the graph node. Next m lines contain pairs of integers. The i-th line contains integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — the indexes of the graph nodes that are connected by the i-th edge. 

It is guaranteed that the given graph doesn't contain any multiple edges or self-loops. It is guaranteed that each node of the graph is connected by the edges with at least k other nodes of the graph.

Output

In the first line print integer r (r ≥ k + 1) — the length of the found cycle. In the next line print r distinct integers v1, v2, ..., vr (1 ≤ vi ≤ n) — the found simple cycle.

It is guaranteed that the answer exists. If there are multiple correct answers, you are allowed to print any of them.

Examples

Input

3 3 2
1 2
2 3
3 1


Output

3
1 2 3 

Input

4 6 3
4 3
1 2
1 3
1 4
2 3
2 4


Output

4
3 4 1 2 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;

public class TC
{
    static ArrayList<Integer>[] adjList;
    static int N, k;    
    
    static void solve() throws IOException
    {
        Stack<State> s=new Stack();
        boolean[] visited=new boolean[ N+1 ];
        Arrays.fill( visited, false );
        int[] len=new int[ N+1 ];
        Arrays.fill( len, -1 );
        State prevPop=null;
        State st=new State( 1, 0, null );
        s.add( st );
        State end=null;
        int src=-1;
        
        while( !s.isEmpty() )
        {
            State curr=s.pop();
            visited[curr.curr]=true;
            len[ curr.curr ]=curr.len;
            
            if( ( prevPop!= null )&&( prevPop.len >= curr.len ) )
            {
                visited[ prevPop.curr ]=false;
                len[ prevPop.curr ]=-1;
            }
            
            prevPop=curr;
                        
            ArrayList<Integer> nbrs=adjList[ curr.curr ];
            for( int x: nbrs )
            {
                if( visited[ x ])
                {
                    int old=len[ x ];
                    int nw=curr.len+1;
                    int l=nw-old;
                    if( l>=k+1 )
                    {
                        end=curr;
                        src=x;
                        break;
                    }
                    else
                       continue;
                }
                
                State t=new State( x, curr.len+1, curr );
                s.add( t );
                break;
            }
                
        }
        
        Stack<Integer> w=new Stack();
        State t=end;
        
        while( t!=null )
        {
            w.add( t.curr );
            if( src==t.curr )
                break;
            t=t.parent;
        }
        
        BufferedWriter out=new BufferedWriter( new OutputStreamWriter( System.out ));
        out.write( Integer.toString(w.size()) + "\n");
        
        while( !w.isEmpty() )
        {
            out.write( Integer.toString(w.pop()) + " ");
        }
        
        out.write("\n");
        out.close();
    }
    public static void main( String[] args ) throws IOException
    {
        BufferedReader br=new BufferedReader( new InputStreamReader( System.in ));
        String s=br.readLine();
        StringTokenizer tok=new StringTokenizer( s );
        N=Integer.parseInt( tok.nextToken() );
        int m=Integer.parseInt( tok.nextToken() );
        k=Integer.parseInt( tok.nextToken() );
        adjList=new ArrayList[ N+1 ];
        for( int i=0; i<N+1; i++ )
        {
            adjList[i]=new ArrayList();
        }
        for( int i=0; i<m; i++ )
        {
            s=br.readLine();
            tok=new StringTokenizer( s );
            int x=Integer.parseInt( tok.nextToken() );
            int y=Integer.parseInt( tok.nextToken() );
            adjList[ x ].add( y );
            adjList[ y ].add( x );
        }
        solve();
    }
}

class State
{
    int len, curr;
    State parent;
    
    
    public State( int curr, int len, State par)
    {
        this.curr=curr;
        this.len=len;
        this.parent=par;
        
    }
}

