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 CF {

    static int K;
    static ArrayList<Integer>[] G;
    static int[] visited;

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int N = nextInt(st);
        int M = nextInt(st);
        K = nextInt(st);

        visited = new int[N];
        G = new ArrayList[N];
        for (int i = 0; i < N; i++)
            G[i] = new ArrayList<Integer>();
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine(), " ");
            int a = nextInt(st) - 1;
            int b = nextInt(st) - 1;
            G[a].add(b);
            G[b].add(a);
        }

        boolean found = false;
        for (int i = 0; i < N && !found; i++) {
            if (visited[i] != -1)
                found = DFS(i, new ArrayList<Integer>(), 1);
        }
    }

    public static boolean DFS(int start, ArrayList<Integer> cycle, int len) {
        if (visited[start] > 0) {
            if (len - visited[start] <= K)
                return false;
            StringBuilder sb = new StringBuilder("");
            sb.append(len - visited[start]);
            sb.append("\n");
            boolean print = false;
            for (Integer i : cycle) {
                if (i == start)
                    print = true;
                if (print)
                    sb.append((i + 1) + " ");
            }
            System.out.println(sb.toString());
            return true;
        }

        visited[start] = len;
        boolean found = false;
        cycle.add(start);
        for (Integer vertex : G[start]) {
            if (found)
                return true;
            if (visited[vertex] != -1) {
                found = DFS(vertex, cycle, len + 1);
                //System.out.println(start + "FOUND");
                if (found)
                    return true;
            }
        }

        cycle.remove(cycle.size() - 1);
        visited[start] = -1;
        return false;
    }

    public static int nextInt(StringTokenizer st) {
        return Integer.parseInt(st.nextToken());
    }

    public static int nextInt(BufferedReader br) throws IOException{
        return Integer.parseInt(br.readLine());
    }
}
