#include <bits/stdc++.h>

#define int_pair std::pair <int, int>

#define MAXN 100005
#define MAXM 500005

int N, M;
bool Seen[MAXM];
std::vector <int_pair> Edges;
std::vector <int> ADC[MAXN];

inline void AddEdge(int X, int Y) {
    ADC[X].push_back(Edges.size());
    ADC[Y].push_back(Edges.size());
    Edges.push_back({X, Y});
}

bool NonEulerian() {
    for (int i=1; i<=N; ++i)
        if (ADC[i].size()&1) return true;
    return false;
}

std::vector <int> Cycle;
std::stack <int> Stack;
void ComputeCycle() {
    Stack.push(1);

    int Top, idx;
    while (!Stack.empty()) {
        Top = Stack.top();

        if (ADC[Top].empty())
            Stack.pop(), Cycle.push_back(Top);
        else {
            idx = ADC[Top].back();
            ADC[Top].pop_back();

            if (Seen[idx]) continue;
            Seen[idx] = 1;
            Stack.push(Edges[idx].first + Edges[idx].second - Top);
        }
    }
}

std::ifstream In ("ciclueuler.in");
std::ofstream Out("ciclueuler.out");

void Citire() {
    In >> N >> M;
    for (int i=1, X, Y; i<=M; ++i)
        In >> X >> Y, AddEdge(X, Y);
}

void Rezolvare() {
    if (NonEulerian()) {
        Out << "-1\n";
        return;
    }

    ComputeCycle();
    for (int i=0; i<Cycle.size()-1; ++i)
        Out << Cycle[i] << ' ';
}

int main()
{
    Citire();
    Rezolvare();

    return 0;
}