#include <fstream>

#include <vector>

#include <stack>

using namespace std;

ifstream fin("ciclueuler.in");

ofstream fout("ciclueuler.out");

int n, m;

vector<vector<pair<int, int>>> adj;

vector<int> position;

vector<bool> used, visited;

void dfs(int node) {

    visited[node] = true;

    for (auto& neighbor : adj[node])
        if (!visited[neighbor.first])
            dfs(neighbor.first);
}

void EulerianCycle() {

    int oddDegreeNodes = 0;

    for (int node = 1; node <= n; ++node)
        if (adj[node].size() % 2 != 0)
            oddDegreeNodes++;
    
    if (oddDegreeNodes != 0) {

        fout << "-1";

        return;
    }

    int start = 0;

    for (int node = 1; node <= n; ++node) {

        if (adj[node].size() != 0) {

            start = node;

            break;
        }
    }

    stack<int> s;

    vector<int> cycle;

    s.push(start);

    while (!s.empty()) {

        int node = s.top();

        bool found = false;

        while (position[node] < adj[node].size()) {

            auto edge = adj[node][position[node]];

            position[node]++;

            if (!used[edge.second]) {

                used[edge.second] = true;

                found = true;

                s.push(edge.first);

                break;
            }
        }

        if (!found) {

            cycle.push_back(node);

            s.pop();
        }
    }

    for (auto it = cycle.rbegin(); it != cycle.rend() - 1; ++it)
        fout << *it << ' ';
}

int main() {

    fin >> n >> m;

    adj.resize(n + 1);

    position.resize(n + 1);

    used.resize(m + 1);

    visited.resize(n + 1);

    for (int i = 1; i <= m; ++i) {

        int a, b;

        fin >> a >> b;

        adj[a].push_back({b, i});

        adj[b].push_back({a, i});
    }

    dfs(1);

    for (int node = 2; node <= n; ++node) {

        if (!visited[node] && adj[node].size() != 0) {

            fout << "-1";

            return 0;
        }
    }

    EulerianCycle();

    return 0;
}