#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <stack>
 
#define Max 100005
#define Max2 500005
 
using namespace std;
 
ifstream fin("ciclueuler.in");
ofstream fout("ciclueuler.out");
 
int N, M;
vector < pair<int,int> > edges[Max];
 
class Graph{
private:
    int NumberOfNodes, NumberOfEdges;
    vector<int> adjacencyList[Max];
 
public:
    Graph(int N, int M); // constructor
    void Eulerian_Cycle();
    void Euler(int Start, vector <bool>&visited,vector <int>&solutions);
};
 
// constructor
Graph :: Graph(int N, int M)
{
    NumberOfNodes = N;
    NumberOfEdges = M;
}
 
void Graph :: Euler(int Start, vector <bool>&visited, vector <int>&solutions)
{
    stack <int> Stack;
    Stack.push(Start);
    while ( !Stack.empty() )
    {
        int node = Stack.top();
        if ( ! edges[node].empty() )
        {
            int next = edges[node].back().first;
            int edge = edges[node].back().second;
            edges[node].pop_back();
            if ( ! visited[edge] )
            {
                visited[edge] = true;
                Stack.push(next);
            }
        }
        else
        {
            solutions.push_back(node);
            Stack.pop();
        }
    }
}
 
void Graph :: Eulerian_Cycle ()
{
    int x, y;
 
    for ( int i = 1; i <= NumberOfEdges; i++ )
    {
        fin >> x >> y; 
        edges[x].push_back( make_pair(y, i) );
        edges[y].push_back( make_pair(x, i) );
    }
    
    // daca nu avem ciclu eulerian
    for ( int i = 0; i <= NumberOfNodes; i++ )
        if ( edges[i].size() % 2 )
        {
            fout << "-1";
            return;
        }
    
    vector <bool> visited(Max2, false);
    vector <int> solutions;
 
    Euler(1, visited, solutions);
 
    // afisare
    for ( int i = 0; i < solutions.size() - 1; i++ )
        fout << solutions[i] << " ";
}
 
int main()
{
    fin >> N >> M;
    Graph G(N, M);
    G.Eulerian_Cycle();
    return 0;
}