#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>
#include <unordered_set>
using namespace std;

using VP = vector<pair<int, int>>;
using VVP = vector<VP>;

int n, m;
VVP G;
stack<int> stk;

void Read();
vector<int> Cycle(int x);

int main()
{
	Read();

	ofstream fout("ciclueuler.out");
	for (int x = 1; x <= n; ++x)
		if (G[x].size() & 1)
		{
			fout << -1;
			return 0;
		}

	const vector<int> result = Cycle(1);

	if ((int)result.size() <= m)
		fout << -1;
	else
		for (size_t i = 0u; i + 1 < result.size(); ++i)
			fout << result[i] << ' ';
}

vector<int> Cycle(int x)
{
	vector<int> result;
	vector<VP::iterator> edges(n + 1);
	unordered_set<int> seenEdges;
	result.reserve(m);

	for (int i = 1; i <= n; ++i)
		edges[i] = G[i].begin();

	stk.push(x);
	while (!stk.empty())
	{
		x = stk.top();
		if (edges[x] == G[x].end())
		{
			stk.pop();
			result.push_back(x);
		}
		else
		{
			const auto [y, e] = *edges[x];
			edges[x]++;
			if (seenEdges.find(e) != seenEdges.end())
				continue;
			seenEdges.insert(e);
			stk.push(y);
		}
	}

	return result;
}

void Read()
{
	ifstream fin("ciclueuler.in");
	fin >> n >> m;
	G = VVP(n + 1);

	int x, y;
	for (int i = 0; i < m; ++i)
	{
		fin >> x >> y;
		G[x].emplace_back(y, i);
		G[y].emplace_back(x, i);
	}

	fin.close();
}