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 
//package ds;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class Cycle {
	
	static LinkedList<Integer>[] G;
	static StringBuilder sb = new StringBuilder();
	static int[] stack;
	static boolean flag=false;
	static int[] par;
	static int sp = 1,k;
	static char[] used;
	static int[] pos;
	
	
	static void find(int u, int p)
	{
		used[u] = 'g';	
		for(int v: G[u])
		{
			if(used[v]=='w'&&v!=p)
			{
				par[v] = u;
				pos[v] = sp;
				stack[sp++] = v;
				find(v,u);
			}
			
			else if(used[v]=='g'&&v!=p)
			{
				int x = sp - pos[v];
			//	System.out.println(x+" x");
				if(x>=k+1&&flag==false)
				{
					flag = true;
					sb = new StringBuilder();
					sb.append(x+"\n");
					for(int i=pos[v];i<sp;i++)
						sb.append(stack[i]+" ");
					return;
				}
			}


		}
	}
	
	public static void main(String[] args) {
		
		FastScanner s = new FastScanner();
		int n = s.nextInt();
		int m = s.nextInt();
		k = s.nextInt();
		
		{
			used = new char[n+1];
			Arrays.fill(used,'w');
			stack = new int[n+1];
			pos = new int[n+1];
			par = new int[n+1];
		}
		
		G = new LinkedList[n+1];
		for(int i=1;i<=n;i++)
			G[i] = new LinkedList<>();
			
		while(m-->0)
		{
			int a = s.nextInt();
			int b = s.nextInt();
			G[a].add(b);
			G[b].add(a);
		}
		
		pos[1] = sp;
		stack[sp++] = 1;
		find(1,-1);
		System.out.println(sb);
	}
	
static class FastScanner {
		
	    private InputStream mIs;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FastScanner() {
			this(System.in);
		}

		public FastScanner(InputStream is) {
			mIs = is;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = mIs.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		
		}	

	}

}
