#include <algorithm>
#include <fstream>
#include <iterator>
#include <stack>
#include <list>
#include <vector>
using namespace std;

inline void del_edge(
        const int& u, const int& v,
        vector<list<int>>& G) {
    G[u].erase( find(G[u].begin(), G[u].end(), v) );
    G[v].erase( find(G[v].begin(), G[v].end(), u) );
}

inline bool visited_all_vertices(const vector<bool>& visited) {
    for (bool x : visited) if (!x) return false;
    return true;
}

inline bool all_degrees_even(const vector<int>& degree) {
    for (int d : degree) if (d % 2) return false;
    return true;
}

int main() {
    ifstream fin("ciclueuler.in");
    ofstream fout("ciclueuler.out");
    
    int n, m; fin >> n >> m;
    vector<list<int>> G(n);
    vector<int> degree(n);
    
    for (; m; --m) {
        int u, v; fin >> u >> v;
        
        G[u-1].push_back(v-1);
        G[v-1].push_back(u-1);
        degree[v]++;
        degree[u]++;
    }
    
    if (!all_degrees_even(degree)) {
        fout << "-1" << endl;
        return 0;
    }
    
    stack<int> recursion;
    vector<int> eulerian_cycle;
    vector<bool> visited(G.size(), false);
    
    recursion.push(0);
    visited[0] = true;
    
    while (!recursion.empty()) {
        int u = recursion.top();
        
        if (G[u].empty()) {
            recursion.pop();
            eulerian_cycle.push_back(u+1);
            continue;
        }
        
        int v = G[u].front();
        recursion.push(v);
        visited[v] = true;
        del_edge(u, v, G);
    }
    
    if (visited_all_vertices(visited))
        copy(
            eulerian_cycle.begin(),
            prev(eulerian_cycle.end()),
            ostream_iterator<int>(fout, " "));
    else
        fout << "-1";
    fout << endl;   
    
    return 0;
}