#include <iostream>
#include <vector>
#include <stack>
#include <unordered_map>
#include <algorithm>
#include <fstream>

using namespace std;

const int MAXN = 100005;

vector<int> adj[MAXN]; // Lista de adiacență
unordered_map<int, int> degree; // Gradul fiecărui nod

void find_eulerian_cycle(int start, vector<int>& circuit) {
    stack<int> curr_path;
    curr_path.push(start);
    vector<int> pos(MAXN, 0);

    while (!curr_path.empty()) {
        int curr_v = curr_path.top();
        if (pos[curr_v] < adj[curr_v].size()) {
            curr_path.push(adj[curr_v][pos[curr_v]++]);
        } else {
            circuit.push_back(curr_v);
            curr_path.pop();
        }
    }
}

bool is_eulerian(int N) {
    for (int i = 1; i <= N; ++i) {
        if (degree[i] % 2 != 0) {
            return false;
        }
    }
    return true;
}

int main() {
    ifstream infile("ciclueuler.in");
    ofstream outfile("ciclueuler.out");

    int N, M;
    infile >> N >> M;

    for (int i = 0; i < M; ++i) {
        int u, v;
        infile >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
        degree[u]++;
        degree[v]++;
    }

    if (!is_eulerian(N)) {
        outfile << -1 << endl;
    } else {
        vector<int> circuit;
        find_eulerian_cycle(1, circuit);
        for (int i = circuit.size() - 1; i >= 0; --i) {
            outfile << circuit[i] << " ";
        }
        outfile << endl;
    }

    infile.close();
    outfile.close();

    return 0;
}