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

const int MAX_N = 100010;
const int MAX_M = 500010;

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

typedef vector<int>::const_iterator iter;

pair<int, int> edges[MAX_M];
vector<int> graph[MAX_N];
vector<int> eulerCycle;
iter it[MAX_N];
bool visited[MAX_M];
int N, M;


void read_input();
bool is_eulerian();
void euler(int node);
void write_output();


int main(int argc, char const *argv[])
{
    read_input();
    if (!is_eulerian()) {
        fout << -1;
    } else {
        euler(1);
        write_output();
    }
    return 0;
}

void read_input() {
    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 is_eulerian() {
    vector<int> degree(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] % 2 == 1) {
            return false;
        }
    }
    // set iterators
    for (int i = 1; i <= N; ++i) {
        it[i] = graph[i].begin();
    }
    return true;
}

void euler(int node) {
    int neighbour;
    while (it[node] != graph[node].end()) {
        if (visited[*it[node]] == false) {
            visited[*it[node]] = true;
            neighbour = edges[*it[node]].first + edges[*it[node]].second - node;
            ++it[node];
            euler(neighbour);
        } else {
            ++it[node];
        }
    }
    eulerCycle.push_back(node);
}

void write_output() {
    for (iter i = eulerCycle.begin(); i != eulerCycle.end(); ++i) {
        fout << *i << ' ';
    }
}