#include <fstream>
#include <vector>
#include <stack>
using namespace std;
 
ifstream fin("ciclueuler.in");
ofstream fout("ciclueuler.out");
 
#define MaxN 100001
 
int n, m;
vector<int>G[MaxN], sol, gr;
stack<int> st;
bool viz[MaxN];

void Write(int);
void Df(int);
void Euler(int);
void Erase(int, int);
int Res();
int Eulerian();


 
int main() {
 
    fin >> n >> m;
    
    sol = gr = vector<int>(n + 1);
    
    for ( int i = 1, x, y; i <= m; ++i ) {
		fin >> x >> y;
		G[x].push_back(y);
		G[y].push_back(x);
		gr[x]++; gr[y]++;
	}
	
	Write(Res());
 
    fin.close();
    fout.close();
    return 0;
}

void Write(int i) {
	if ( i < 0 )
		fout << "-1\n";
	else
		for ( vector<int>::reverse_iterator rit = sol.rbegin(); rit != sol.rend(); ++rit )
			if ( *rit ) 
				fout << *rit << ' ';
}

void Erase(int i, int j) {
	gr[i]--;
	gr[j]--;
	G[i].erase(G[i].begin());
	for ( vector<int>::iterator it = G[j].begin(); it != G[j].end(); ++it ) 
		if ( *it == i )  {
			G[j].erase(it);
			break;
		}
}

int Res() {
	int v = Eulerian();
	if ( v == -1 ) 
		return -1;
	do {
		Euler(v);
		v = st.top(); st.pop();
		sol.push_back(v);
	}while(!st.empty());
	return 1;
}

void Euler(int nod) {
	while(true) {
		if ( G[nod].empty() )
			break;
		int vecin = G[nod].front();
		st.push(nod);
		Erase(nod, vecin);
		nod = vecin;
	}
}

int Eulerian() {
	for ( int i = 1; i <= n; ++i )
		if ( gr[i] & 1 )
			return -1;
	Df(1);
	
	for ( int i = 1; i <= n; ++i )
		if ( !viz[i] ) 
			return -1;
		
	return 1;	
}

void Df(int i) {
	viz[i] = 1;
	for ( const auto &y : G[i] ) 
		if ( !viz[y] )
			Df(y);
}