#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 BListElement;

BListElement *elements;
int allocIndex = 1;


struct BListElement
{	
	int value;
	int next;
	int prev;
};


struct BList
{

	BList()
	{
		size = 0;
		first = allocIndex++;
		elements[first].next = first;
		elements[first].prev = first;
	}


	int size;
	int first;

	int Pb(int value)
	{
		int added = allocIndex++;

		elements[added].value = value;
		elements[added].prev = first;
		elements[added].next = elements[first].next;
		elements[elements[first].next].prev = added;
		elements[first].next = added;

		size++;

		return added;
	}
	void Remove(int index)
	{
		size--;

		int prev = elements[index].prev;
		int next = elements[index].next;

		elements[prev].next = next;
		elements[next].prev = prev;
	}
	
};


BList *Vec;



struct Edge
{
	int x1;
	int x2;

	int p1;
	int p2;

	void Remove()
	{
		Vec[x1].Remove(p1);
		Vec[x2].Remove(p2);
	}

};

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);
	elements = new BListElement[M * 2 + 2*(N + 1)];
	Vec = new BList[N + 1];
	for(int i = 0; i < M; i++)
	{
		int x, y;
		fin >> x >> y;

		edges[i].x1 = x;
		edges[i].x2 = y;

		int p1 = Vec[x].Pb(i);
		int p2 = Vec[y].Pb(i);

		edges[i].p1 = p1;
		edges[i].p2 = p2;

		grad[x] ++;
		grad[y] ++;
	}
	fin.close();
}


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


	while(s.empty() == false)
	{
		int current = s.top();


		if(Vec[current].size > 0)
		{
			int edge = elements[elements[Vec[current].first].next].value;

			int dst = edges[edge].x1 == current ? edges[edge].x2 : edges[edge].x1;
			s.push(dst);

			edges[edge].Remove();

			M--;
		}	
		else
		{
			s.pop();
			eulerCycle.push_back(current);
		}
	}
	
			
}





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();
}