// clang-format off
	#define BADSEED chrono::high_resolution_clock::now().time_since_epoch().count()
	#include <bits/stdc++.h>
	using namespace std;
	using uint = unsigned int;
	#define TM_(...) template <class __VA_ARGS__>
	#define ENABLE(...) TM_(T) static enable_if_t<__VA_ARGS__>
	#define SFINAE(name, ...)                                                  \
		TM_(, class = void) struct name##_s : false_type {};                   \
		TM_(T) struct name##_s<T, decltype(void(__VA_ARGS__))> : true_type {}; \
		TM_(T) constexpr bool name = name##_s<T>::value;
	ostream &operator<<(ostream &os, int8_t c) { return os << static_cast<int>(c); }
	namespace narut {
		TM_(T) using TupSz = tuple_size<decay_t<T>>;
		SFINAE(Iterable, begin(declval<T &>()))
		SFINAE(IsTuple, TupSz<T>{})
		SFINAE(Coutable, cout << declval<T &>())
		SFINAE(Cinable, cin >> declval<T &>())
		TM_(T) constexpr char Spc(T &&) { return (Iterable<T> or IsTuple<T>) ? '\n' : ' '; }
		template <ostream &os, bool Red> struct Writer {
			ENABLE(Coutable<T>) Write(T const &t) { os << t; }
			ENABLE(!Coutable<T> and Iterable<T>) Write(T const &t) {
				auto it = begin(t), e = end(t);
				if (it != e) Write(*it++);
				for (; it != e; Write(*it++)) os << Spc(*it);
			}
			TM_(T, size_t... Is) static void WriteTup(T const &t, index_sequence<Is...>) {
				(void)(int[]){0, ((Is == 0) ? 0 : ((os << ' '), 0), Write(get<Is>(t)), 0)...};
			}
			ENABLE(!Coutable<T> and !Iterable<T> and IsTuple<T>) Write(T const &t) {
				WriteTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			void operator()() const { os << '\n'; }
			TM_(F, class... Ts) void operator()(F const &f, Ts const &... ts) {
				if (Red) os << "\033[0;31m";
				Write(f);
				(void)(int[]){0, (os << ' ', Write(ts), 0)...};
				if (Red)
					os << "\033[0m\n";
				else
					os << '\n';
			}
		};
		struct Cin {
			ENABLE(Cinable<T>) Read(T &t) { cin >> t; }
			ENABLE(!Cinable<T> and Iterable<T>) Read(T &t) {
				for (auto &&x : t) Read(x);
			}
			TM_(T, size_t... Is) static void ReadTup(T &t, index_sequence<Is...>) {
				(void)(int[]){0, (Read(get<Is>(t)), 0)...};
			}
			ENABLE(!Cinable<T> and !Iterable<T> and IsTuple<T>) Read(T &t) {
				ReadTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			TM_(T) void operator()(T &t) const { Read(t); }
			TM_(T) void operator()(T &t, uint n) const { t.resize(n), Read(t); }
			TM_(T) operator T() const {
				T t;
				return Read(t), t;
			}
		};
		struct Big {
			TM_(T) constexpr operator T() const {
				return 0x3f3f3f3f3f3f3f3f & numeric_limits<T>::max();
			}
		};
		TM_(T, size_t N, size_t... Ns) struct arr {
			using type = array<typename arr<T, Ns...>::type, N>;
		};
		TM_(T, size_t N) struct arr<T, N> { using type = array<T, N>; };
		TM_(T, size_t N, size_t... Ns) using Arr = typename arr<T, N, Ns...>::type;
		template <class C, class T> auto Fill(C &c, T const &t) -> decltype(void(*begin(c) = t)) {
			fill(begin(c), end(c), t);
		}
		template <class C, class T> auto Fill(C &c, T const &t) -> decltype(void(begin(*begin(c)))) {
			for (auto &x : c) Fill(x, t);
		}
	} // namespace narut
	narut::Cin Cin;
	narut::Writer<cout, false> Cout;
	narut::Big Big;
	using narut::Arr;
	using narut::Fill;
	using ll = long long;
	#define FOR(i, j, n) for (int i = static_cast<int>(j); i < static_cast<int>(n); ++i)
	#define ROF(i, j, n) for (int i = static_cast<int>(n) - 1; i >= static_cast<int>(j); --i)
	#ifdef NARUT_LOCAL
	narut::Writer<cerr, true> Cerr;
	#define DBG(...) __VA_ARGS__
	#define Debug(...) Cerr(__VA_ARGS__)
	#else
	#define Debug(...) 0
	#define DBG(...)
	#endif
	#ifndef BADSEED
	#define BADSEED random_device{}()
	#endif

// clang-format on
// STUCK : READ THE PROBLEM CAREFULLY. LOOK AT ALL THE CONSTRAINTS




template <int Base, bool Directed = false> auto ReadGraph(int n, int m) {
	vector<vector<int>> G(n + Base);
	FOR(i, 0, m) {
		int u, v;
		cin >> u >> v;
		if (Base == 0) --u, --v;
		G[u].push_back(v);
		if (!Directed) G[v].push_back(u);
	}
	return G;
}

vector<int> ans;
int n, m;
vector<vector<int> > G;


void BFS(int s) {
	vector<int> last(n+1, -1);
	queue<int> q;
	for (int v: G[s]) {
		q.push(v);
		last[v] = s;
	}

	while (q.size()) {
		int u = q.front();
		q.pop();
		if (u == s) {
			vector<int> cyc = {s};
			for (int p = last[s]; p != s; p = last[p]) {
				cyc.push_back(p);
			}			
			if (ans.empty() or ans.size() > cyc.size()) {
				ans = move(cyc);
			}			
			return;
		}
		for (int v : G[u]) {
			if (last[v] != -1) continue;
			q.push(v);
			last[v] = u;
		}				
	}
}

auto Run()
{
	cin>>n>>m;
	G = ReadGraph<1,true>(n, m);

	FOR(s,1,n+1) BFS(s);

	if (ans.empty()) cout << -1;
	else {
		Cout(ans.size());
		for (int i : ans) Cout(i);
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout << fixed << setprecision(10);
#ifdef NARUT_LOCAL
	cerr << fixed << setprecision(10);
	assert(freopen("./io/test.in", "r", stdin));
	// assert(freopen("./io/test.out", "w", stdout));
#endif

	Run();
}


Measured memory_bytes: 384