#include<fstream>
#include<vector>
#include<list>
#include<stack>
#include<bitset>
#include<queue>

using namespace std;
typedef int var;

ifstream fin("ciclueuler.in");
ofstream fout("ciclueuler.out");

struct Edge {
    var n, i;
    Edge(var a, var b) : n(a), i(b) {}
};

const var MAXN = 100001;

bool TAKEN[MAXN];
bool VIZ[MAXN];
vector<Edge> G[MAXN];
var n, m, D[MAXN];

void euler(const var &start) {

    stack<var> st;
    st.push(start);

    while(!st.empty()) {
        var node = st.top();
        st.pop();
        while(!G[node].empty() && TAKEN[G[node].back().i])
            G[node].pop_back();
        if(!G[node].empty()) {
            var vec = G[node].back().n;
            TAKEN[G[node].back().i] = 1;
            G[node].pop_back();
            st.push(vec);
            fout<<vec<<" ";
        }
    }
}

var count;
queue<var> Q;
void dfs(const var &start) {
    VIZ[start] = 1;
    count ++;
    Q.push(start);

    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        for(vector<Edge>::iterator it = G[node].begin(); it != G[node].end(); ++it) {
            var &vec = (*it).n;
            if(!VIZ[vec]) {
                VIZ[vec] = 1;
                count++;
                Q.push(vec);
            }
        }
    }
}

int main() {
    var a, b;
    fin>>n>>m;
    for(var i=1; i<=m; i++) {
        fin>>a>>b;
        G[a].push_back(Edge(b, i));
        G[b].push_back(Edge(a, i));
        D[a]++;
        D[b]++;
    }

    for(var i=1; i<=n; i++) {
        if(D[i] % 2) {
            fout<<-1;
            return 0;
        }
    }
    dfs(1);
    if(count < n) {
        fout<<-1;
        return 0;
    }

    euler(1);
    return 0;
}