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.util.*;
import java.io.*;

public class Main implements Runnable {
	boolean[] visited;
        ArrayList<Integer> path;
        ArrayList<Integer>[] edges;
        int[] depth;
        
        //learnt it from =>"mmaxio" =>Thanks
        public int[] dfs(int at, int curDepth){
               visited[at] = true;
               path.add(at);
               depth[at] = curDepth;
               
               int firstNode = curDepth;
               
               for(int now : edges[at]){
                       if(!visited[now]){
                               return dfs(now, curDepth + 1); //note we visiting on unvisited, hence there is not chance of infinte loop
                       }
                       else if(depth[now] < firstNode){
                               //since this "now" node is already visited, it is not its child node but indeed its previous node
                               //just like its great great grandparent, hence this one is like its firstNode and the "at" node is its actual 
                               //child node which on further expansion forms a loop.
                               //Hence this loop starts at "firstNode" and ends at "at" 
                               firstNode = depth[now]; 
                       }
               }
               
               //so now we have found the firstNode of the loop which ends at "at" => [firstNode, ...... , at] is loop
               int L = curDepth - firstNode + 1;
               int[] ans = new int[L];
               for(int i = firstNode; i <= curDepth; i++) ans[i - firstNode] = path.get(i);
               
               return ans;
        }	
        

	public void solve() throws IOException {
		//since every node is connected to k edges, any circle will have greater than k + 1 nodes
                //so just finding even one circle will work
                int N = nextInt(); int e = nextInt(); int K = nextInt();
                edges = new ArrayList[N];
                for(int i = 0; i < N; i++) edges[i] = new ArrayList<Integer>();

                for(int i = 0; i < e; i++){
                        int from = nextInt() - 1;
                        int to = nextInt() - 1;
                        edges[from].add(to);
                        edges[to].add(from);
                }
                
                depth = new int[N];
                path = new ArrayList<Integer>();
                visited = new boolean[N];

                int[] cycle = dfs(0, 0);//the biggest cycle
                
                System.out.println(cycle.length);
                for(int i = 0; i < cycle.length; i++) System.out.print((cycle[i] + 1) + " ");
                System.out.println();
	}

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	//-----------------------------------------------------------
	public static void main(String[] args) {
		new Main().run();
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

	public String nextToken() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}