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

public class D263 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        String[] s1 = inp.readLine().split(" ");
        int vertices = Integer.parseInt(s1[0]);
        int edges = Integer.parseInt(s1[1]);
        int z = Integer.parseInt(s1[2]);
        GraphD263 graph = new GraphD263(vertices);
        for(int i=0;i<edges;i++){
            String[] s2 = inp.readLine().split(" ");
            graph.addEdge(Integer.parseInt(s2[0]),Integer.parseInt(s2[1]));
        }
        graph.DFS(z+1);
    }
}
class GraphD263{
    int vertices;
    ArrayList<Integer> edge[];
    static Map<Integer,Integer> parent;
    GraphD263(int vertices){
        this.vertices = vertices;
        edge = new ArrayList[vertices+1];
        parent = new HashMap<>();
        for(int i=0;i<=vertices;i++){
            edge[i] = new ArrayList<>();
        }

    }
    void addEdge(int a,int b){
        edge[a].add(b);
        edge[b].add(a);
    }
    void DFS(int z){
        Set<Integer> greySet = new HashSet<>();
        boolean[] visited = new boolean[vertices+1];
        parent.put(1,0);
        ArrayList<Integer> list = DFSutil(1,greySet,visited,z);
        System.out.println(list.size());
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i)+" ");
        }
    }

    private ArrayList<Integer> DFSutil(int v, Set<Integer> greySet, boolean[] visited,int z) {
        ArrayList<Integer> ret = new ArrayList<>();
        visited[v] = true;
        greySet.add(v);
        Iterator<Integer> iterator = edge[v].listIterator();
        while (iterator.hasNext()){
            int n = iterator.next();
            if(!visited[n] && parent.get(v)!=n){
                parent.put(n,v);
                ret = DFSutil(n,greySet,visited,z);
                if(ret.size()>=z){
                    return ret;
                }
                else {
                    continue;
                }
            }
            else if(parent.get(v)!=n){
                if(greySet.contains(n)){
                    boolean loop = true;
                    int loopAt = n;
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(n);
                    list.add(v);
                    int check = v;
                    while (loop){
                        //System.out.println(parent +" " +v+" "+n);
                        if(parent.get(check)==n){
                            if(list.size()>=z){
                                //System.out.println(list);
                                return list;
                            }
                            else{
                                loop = false;
                            }
                        }
                        else{
                            list.add(parent.get(check));
                            check = parent.get(check);
                        }
                    }
                }
            }
        }
        greySet.remove(v);
        return ret;
    }

}
