#if 1
#define _USE_MATH_DEFINES
#include <math.h>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <utility>
#include <sstream>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <fstream>
#include <chrono>
using namespace std;
using namespace std::chrono;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<ull> vull;
typedef vector<vull> vvull;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vstring;
typedef vector<double> vdouble;

#define fs first
#define sc second
#define pb push_back
// forward strict for, most common
#define fors(i, a, n) for (int i = (int) (a); i < (int) (n); ++i)
// forward inclusive for
#define fori(i, a, n) for (int i = (int) (a); i <= (int) (n); ++i)
// backward for, inclusive
#define forb(i, n, a) for (int i = (int) (n); i >= (a); --i)

template <typename T>
void print(string name, vector<T>& v) {
    if (name.size()) cout << name << ": ";
    int s = (int) v.size();
    fors(i, 0, s) cout << v[i] << " ";
    cout << endl;
}
template<typename T> void print(vector<T>& v) { print("", v); }
#endif

struct edge {
    int u, v;
    edge* b; // pointer to backward edge
    int s; // status
};

class Problem {
public:
    int n, m;
    vector<list<edge>> adj;
    vint d;
    vint touched;
    vector<int> l2;
    
    void solve() {
        ifstream in("ciclueuler.in");
        ofstream out("ciclueuler.out");
        in >> n >> m;
        adj.resize(n + 1);
        d.resize(n + 1);
        fors(i, 0, m) {
            int u, v;
            in >> u >> v;
            adj[u].push_back(edge());
            adj[v].push_back(edge());
            edge &e1 = adj[u].back(), &e2 = adj[v].back();
            e1.u = u, e1.v = v, e1.b = &e2, e1.s = 1;
            e2.u = v, e2.v = u, e2.b = &e1, e2.s = 1;
        }
        bool even = true;
        fori(i, 1, n) {
            d[i] = adj[i].size();
            if (d[i] % 2) {
                even = false;
                break;
            }
        }
        
        if (!even) {
            out << -1 << endl;
            return;
        }
        
        touched.resize(n + 1);
        queue<int> Q;
        Q.push(1);
        touched[1] = 1;
        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            for(edge e : adj[u]) if (!touched[e.v]) touched[e.v] = 1, Q.push(e.v);
        }
        
        // check if connected
        int t = 0;
        fori(i, 1, n) t += touched[i];
        if (t != n) {
            out << -1 << endl;
            return;
        }
        
//        cout << "Even degrees and connected" << endl;
//        cout << "Parse eulerian: ";
        //parse_eulerian(1);
//        cout << endl;
        
//        cout << "l2: ";
        for(int u : l2) out << u << " ";
        out << endl;

    }
    
    void parse_eulerian(int u) {
//        l1.push_back(u);
//        cout << u << " ";
        for(edge& e : adj[u]) {            
            if (e.s == 1) {
                e.s = 0;
                e.b->s = 0;
                parse_eulerian(e.v);
            }
        }
        // done
//        l1.pop_back();
        l2.push_back(u);
    }
};

int main() {
    Problem p;
    p.solve();
    
    return 0;
}