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

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

const int DIM = 100004;
int n, m;
list<int> G[DIM];
vector<int> grd;
list<int> L;
stack<int> S;
vector<bool> s;

void Read();
void Write();
void Euler(int v);
void Erase(int v, int w);
void BFS(int x);
bool Eulerian();
void Solve();

int main() {
    Read();
    if (!Eulerian()) {
        fout << "-1";
        fin.close();
        fout.close();
        return 0;
    }
    Solve();
    Write();
    fin.close();
    fout.close();
    return 0;
}

void Erase(int v, int w) {
    grd[v]--; grd[w]--;
    G[v].pop_front();
    for (list<int> :: iterator it = G[w].begin(); it != G[w].end(); ++it)
        if (*it == v) {
            G[w].erase(it);
            break;
        }
}

void Euler(int v) {
    while (true) {
        if (G[v].empty()) break;
        int w = G[v].front();
        S.push(v);
        Erase(v, w);
        v = w;
    }
}

void Solve() {
    int v = 1;
    do {
        Euler(v);
        v = S.top(); S.pop();
        L.push_back(v);
    } while (!S.empty());
}

bool Eulerian() {
    for (int i = 1; i <= n; i++)
        if (grd[i] % 2 == 1) return false;
    BFS(1);
    for (int i = 1; i <= n; i++)
        if (!s[i]) return false;
    return true;
}

void BFS(int x) {
    queue<int> Q;
    s[x] = true;
    Q.push(x);
    while (!Q.empty()) {
        x = Q.front(); Q.pop();
        for (const auto & e : G[x])
            if (!s[e]) {s[e] = true; Q.push(e);}
    }
}

void Write() {
    for (auto it = L.begin(); it != L.end(); ++it)
        fout << *it << ' ';
}

void Read() {
    fin >> n >> m;
    grd = vector<int>(n + 1);
    s = vector<bool>(n + 1);
    for (int i = 1, x, y; i <= m; i++) {
        fin >> x >> y;
        G[x].push_back(y);
        G[y].push_front(x);
        grd[x]++; grd[y]++;
    }
}