#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <string.h>
#include <iomanip>
#include <time.h>
#include <list>
using namespace std;


const string file = "ciclueuler";

const string infile = file + ".in";
const string outfile = file + ".out";


#define NMAX 100003
#define MMAX 500003

list<int> G[NMAX];

struct Edge
{
	int x1;
	int x2;
	list<int>::iterator itr1;
	list<int>::iterator itr2;
	
	void Remove()
	{

		G[x1].erase(itr1);
		G[x2].erase(itr2);

	}
};




int grad[NMAX];
Edge edges[MMAX];
vector<int> eulerCycle;
bool viz[NMAX];
int totalVisited;
int N;
int M;

void citire()
{
	ifstream fin(infile.c_str());

	fin >> N >> M;
	eulerCycle.reserve(M);
	
	for(int i = 0; i < M; i++)
	{
		int x, y;
		fin >> x >> y;

		edges[i].x1 = x;
		edges[i].x2 = y;
		edges[i].itr1 = G[x].insert(G[x].begin(), i);
		edges[i].itr2 = G[y].insert(G[y].begin(), i);

		grad[x] ++;
		grad[y] ++;
	}


	fin.close();
}



void DFS(int v)
{
	
	stack<int> nodes;
	nodes.push(v);

	while(nodes.empty() == false)
	{
		int currentNode = nodes.top();
		if(viz[currentNode] == false)
		{
			viz[currentNode] = true;
			++totalVisited;
		}

		if(G[currentNode].size() > 0)
		{
			int edge = G[currentNode].front();

			nodes.push(currentNode == edges[edge].x1 ? edges[edge].x2 : edges[edge].x1);

			edges[edge].Remove();
		}
		else
		{
			eulerCycle.push_back(nodes.top());
			nodes.pop();
		}

	}
			
}


void solve()
{
	ofstream fout(outfile.c_str());
	
	for(int i = 1; i <= N; i++)
	{
		if(grad[i] % 2 == 1)
		{
			fout << "-1\n";
			return;
		}
	}

	DFS(1);

	if(totalVisited != N)
	{
		fout << "-1\n";
		return;
	}

	for(unsigned int i = 0; i < eulerCycle.size() - 1; i++)
	{
		fout << eulerCycle[i] << " ";
	}
	fout << "\n";
	fout.close();

}

void afisare()
{

}

int main()
{

	citire();
	solve();

}