#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
    list<edge>::iterator itb; // iterator pointing to the 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());
            list<edge>::iterator it1 = adj[u].end();
            it1--;
            edge &e1 = *it1;
            e1.u = u, e1.v = v, e1.s = 1;
//            if (u != v) {
            adj[v].push_back(edge());
            list<edge>::iterator it2 = adj[v].end();
            it2--;
            edge &e2 = *it2;
            e1.itb = it2;
            e2.u = v, e2.v = u, e2.itb = it1, 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;
        }

//        print_adj();

//        cout << "Even degrees and connected" << endl;
//        cout << "Parse eulerian: ";
        parse_eulerian(1);
//        cout << endl;

        for (int u : l2)
            out << u << " ";
        out << endl;

    }

    void parse_eulerian(int u) {
        while (!adj[u].empty()) {
            auto it = adj[u].begin();
            auto itb = it->itb;
            int v = it->v;
            adj[u].erase(it);
            if (u != v) adj[v].erase(itb);
            parse_eulerian(v);
        }
        // done
        l2.push_back(u);
    }

    void print_adj() {
        fori(i, 1, n)
        {
            cout << "adj " << i << ": ";
            for (auto e : adj[i])
                cout << e.v << " ";
            cout << endl;
        }
    }
};

int main() {
    Problem p;
    p.solve();

    return 0;
}