#include <algorithm>
#include <fstream>
#include <vector>
using namespace std;

const int MAX_N = 100005;
const int MAX_M = 500005;

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

int n, m;

pair<int, int> edges[MAX_M];
bool vis[MAX_M];

vector<int> graph[MAX_N];
vector<int>::iterator it[MAX_N];

vector<int> euler_cycle;

void read() {
    fin >> n >> m;
    for (int i = 1; i <= m; ++i) {
        fin >> edges[i].first >> edges[i].second;
        graph[edges[i].first].push_back(i);
        graph[edges[i].second].push_back(i);
    }
}

bool no_solution() {
    vector<int> degree = vector<int>(n + 1);
    for (int i = 1; i <= m; ++i) {
        ++degree[edges[i].first];
        ++degree[edges[i].second];
    }
    for (int i = 1; i <= n; ++i)
        if (degree[i] & 1)
            return true;
    return false;
}

void init() {
    for (int i = 1; i <= n; ++i)
        it[i] = graph[i].begin();
}

int neighbour; // avoid MLE(?)
void euler_dfs(int node) {
    while (it[node] != graph[node].end()) {
        if (vis[*it[node]]) {
            ++it[node];
            continue;
        }
        neighbour = edges[*it[node]].first + edges[*it[node]].second - node;
        vis[*it[node]] = true;
        ++it[node];
        euler_dfs(neighbour);
    }
    euler_cycle.push_back(node);
}

void write() {
    for (size_t i = 1; i < euler_cycle.size(); ++i)
        fout << euler_cycle[i] << " ";
}

int main() {
    read();

    if (no_solution()) {
        fout << "-1\n";
        return 0;
    }

    init();
    euler_dfs(1);
    write();
}