#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



struct Edge
{
	int x1;
	int x2;

};

vector<int> G[NMAX];
int grad[NMAX];
Edge edges[MMAX];

vector<int> eulerCycle;

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;
		G[x].push_back(i);
		G[y].push_back(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(G[currentNode].size() > 0)
		{
			int edge = G[currentNode].back();

			int dst = currentNode == edges[edge].x1 ? edges[edge].x2 : edges[edge].x1;
			nodes.push(dst);
			G[currentNode].pop_back();
			for(unsigned int i = 0; i < G[dst].size(); i++)
			{
				if(G[dst][i] == edge)
				{
					G[dst][i] = G[dst].back();
					G[dst].pop_back();
					
					break;
				}
			}
			--M;
			
		}
		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 || grad[i] == 0)
		{
			fout << "-1\n";
			fout.close();
			return;
		}
	}

	DFS(1);

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

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

}


int main()
{
	citire();
	solve();
}