#include <list>
#include <vector>
#include <queue>
#include <fstream>
#include <stack>

using namespace std;

#define MAXN	10002

stack<int> StackNodes;
list<int> Neighboors[MAXN], EulerPath;
int N, M, S;
int degree[MAXN];

void ReadData()
{
	int x, y;
	scanf("%d", &N);
	scanf("%d", &M);
	//scanf("%d", &S); 
	S = 1;

	for (int i = 0; i < M; i++)
	{
		scanf("%d %d", &x, &y);
		Neighboors[x].push_back(y);
		Neighboors[y].push_back(x);

		degree[x]++;
		degree[y]++;
	}
}

void DeleteEdge(int x, int y)
{
	Neighboors[x].pop_front();
	for (list<int>::iterator it = Neighboors[y].begin(); it != Neighboors[y].end(); it++)
		if (*it == x)
		{
			Neighboors[y].erase(it);
			break;	
		}
}

bool IsEulerianGraph()
{
	// Even degrees ?
	for (int i = 1; i <= N; i++) 
		if (degree[i] % 2 == 1)
			return false;

	// Is conex ?
	queue<int> nodesQueue; 
	bool visited[MAXN]; memset(visited, false, sizeof(visited));
	visited[1] = true; nodesQueue.push(1);
	while(!nodesQueue.empty())
	{
		int oldNode = nodesQueue.front();
		nodesQueue.pop();
		for (list<int>::iterator it = Neighboors[oldNode].begin(); it != Neighboors[oldNode].end(); it++)
			if (visited[*it] == false)
			{
				visited[*it] = true;
				nodesQueue.push(*it);
			}
	}

	for (int i = 1; i <= N; i++)
		if (visited[i] == false)
			return false;

	return true;
}



void Solve()
{
	if (!IsEulerianGraph())
	{
		printf("-1\n");
		return;
	}

	int start = S;
	do
	{
		while(true)
		{
			if (Neighboors[start].empty())
				break;
			int next = Neighboors[start].front();
			StackNodes.push(start);
			DeleteEdge(start, next);
			start = next;
		}

		start = StackNodes.top(); StackNodes.pop();
		EulerPath.push_back(start);
	}while(!StackNodes.empty());
	
	EulerPath.push_front(EulerPath.back());
	for (list<int>::reverse_iterator it = EulerPath.rbegin(); it != EulerPath.rend(); it++)
		printf("%d ", *it);
	printf("\n");
}

int main()
{
	freopen("ciclueuler.in", "r", stdin);
	freopen("ciclueuler.out", "w", stdout);

	ReadData();
	Solve();
	return 0;
}