#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ță
vector<pair<int, int>> edges; // Lista de muchii
unordered_map<int, int> edge_count; // Harta pentru a ține evidența muchiilor rămase

void find_eulerian_path(int start, vector<int>& circuit) {
    stack<int> curr_path;
    curr_path.push(start);
    int curr_v = start;

    while (!curr_path.empty()) {
        if (!adj[curr_v].empty()) {
            curr_path.push(curr_v);
            int next_v = adj[curr_v].back();
            adj[curr_v].pop_back();
            adj[next_v].erase(find(adj[next_v].begin(), adj[next_v].end(), curr_v));
            curr_v = next_v;
        } else {
            circuit.push_back(curr_v);
            curr_v = curr_path.top();
            curr_path.pop();
        }
    }
}

bool is_connected(int N) {
    vector<bool> visited(N + 1, false);
    stack<int> s;
    for (int i = 1; i <= N; ++i) {
        if (!adj[i].empty()) {
            s.push(i);
            break;
        }
    }
    if (s.empty()) return false;

    while (!s.empty()) {
        int v = s.top();
        s.pop();
        if (!visited[v]) {
            visited[v] = true;
            for (int u : adj[v]) {
                if (!visited[u]) {
                    s.push(u);
                }
            }
        }
    }

    for (int i = 1; i <= N; ++i) {
        if (!adj[i].empty() && !visited[i]) return false;
    }
    return true;
}

bool is_eulerian(int N) {
    if (!is_connected(N)) return false;
    int odd_degree_count = 0;
    for (int i = 1; i <= N; ++i) {
        if (adj[i].size() % 2 != 0) {
            odd_degree_count++;
        }
    }
    return (odd_degree_count == 0);
}

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);
        edges.push_back({u, v});
    }

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

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

    return 0;
}