#include <fstream>
#include <utility>
#include <vector>
#include <stack>
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;
stack<int> nodes;
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) {
    nodes.push(node);
    while (!nodes.empty()) {
        int neighbour;
        node = nodes.top();
        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];
                nodes.push(neighbour);
                break;
            // euler(neighbour);
            } else {
                ++it[node];
            }
        }
        if (it[nodes.top()] == graph[nodes.top()].end()) {
            eulerCycle.push_back(nodes.top());
            nodes.pop();
        }
    }
}

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