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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Washoum
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        inputClass in = new inputClass(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DCycleInGraph solver = new DCycleInGraph();
        solver.solve(1, in, out);
        out.close();
    }

    static class DCycleInGraph {
        private static ArrayList<Integer> ans;
        static int brek;
        static boolean fini;
        private static int[] stack;
        private static DCycleInGraph.Node[] graph;
        private static boolean[] visited;
        private static int n;
        private static int k;
        private static int m;

        private static boolean dfs(int a, int kadeh, int p) {
            if (stack[a] > 0 && kadeh - stack[a] > k) {
                brek = a;
                ans.add(a);
                return true;
            }

            if (visited[a]) {
                return false;
            }


            visited[a] = true;
            stack[a] = kadeh;
            for (int fils : graph[a].edges) {
                if (fils == p) continue;
                if (fini) break;
                if (dfs(fils, kadeh + 1, a)) {
                    if (a != brek) {
                        ans.add(a);
                        return true;
                    } else {
                        fini = true;
                        return false;
                    }
                }
            }
            stack[a] = 0;
            return false;
        }

        public void solve(int testNumber, inputClass sc, PrintWriter out) {
            n = sc.nextInt();
            m = sc.nextInt();
            k = sc.nextInt();
            graph = new DCycleInGraph.Node[n];
            stack = new int[n];
            fini = false;
            visited = new boolean[n];
            for (int i = 0; i < n; i++) {
                graph[i] = new DCycleInGraph.Node();
                graph[i].edges = new ArrayList<>();
            }
            int x, y;
            for (int i = 0; i < m; i++) {
                x = sc.nextInt() - 1;
                y = sc.nextInt() - 1;
                graph[x].edges.add(y);
                graph[y].edges.add(x);
            }
            ans = new ArrayList<>();
            dfs(0, 1, -1);
            out.println(ans.size());
            for (int i = ans.size() - 1; i >= 0; i--) {
                out.print(ans.get(i) + 1 + " ");
            }
            out.println();

        }

        static class Node {
            ArrayList<Integer> edges;

        }

    }

    static class inputClass {
        BufferedReader br;
        StringTokenizer st;

        public inputClass(InputStream in) {

            br = new BufferedReader(new InputStreamReader(in));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

