#include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <utility>
using namespace std;

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

#define x first
#define y second

const int INF = 1 << 30;
const int MAX_N = 100100;
const int MAX_M = 500100;

vector<int> graph[MAX_N];
pair<int, int> edges[MAX_N];
vector<int>::iterator node_it[MAX_N];
bool visited[MAX_N];
int grd[MAX_N];

int num_edges, num_nodes;
vector<int> sol;

void read_input();
int other(int edge, int node);
void euler(int node);
inline bool is_euler();

int main()
{
    read_input();
    if (not is_euler()) {
        fout << -1;
    } else {
        for (int i = 1; i <= num_nodes; i += 1) {
            node_it[i] = graph[i].begin();
        }
        euler(1);
        for (int i = 0; i < sol.size() - 1; i += 1) {
            fout << sol[i] << ' ';
        }
    }
    return 0;
}
void read_input() {
    fin >> num_nodes >> num_edges;
    for (int i = 1; i <= num_edges; i += 1) {
        fin >> edges[i].x >> edges[i].y;
        graph[edges[i].x].push_back(i);
        graph[edges[i].y].push_back(i);
    }
}

inline int other(int edge, int node) {
    return edges[edge].x + edges[edge].y - node;
}

inline bool is_euler() {
    for (int i = 1; i <= num_edges; i += 1) {
        grd[edges[i].x]++;
        grd[edges[i].y]++;
    }

    for (int i = 1; i <= num_nodes; i += 1) {
        if (grd[i] % 2 != 0) {
            return false;
        }
    }
    return true;
}

void euler(int node) {
    //cerr << node << endl;
    //cerr << node << ' ' << node_it[node] - graph[node].begin() << ' ' << graph[node].end() - graph[node].begin() << endl;
    while (node_it[node] != graph[node].end()) {
        int edge = *node_it[node];
        if (visited[edge]) {
            ++node_it[node];
        } else {
            if (visited[edge]) continue;
            visited[edge] = true;
            int next = other(edge, node);
            ++node_it[node];
            euler(next);
        }
    }

    sol.push_back(node);
}