/* 
 * File:   CicluEulerian.cpp
 * Author: slycer
 *
 * Created on December 31, 2011, 6:30 PM
 */

#include <cstdlib>
#include <vector>
#include <algorithm>
#include <set>
#include <fstream>
#include <iostream>

using namespace std;

class Graf {
public:
    int n;
    vector<int> *data;
    int *grad;

    Graf(int n) {
        this->n = n;
        data = new vector<int>[n + 1];
        grad = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            grad[i] = 0;
        }
    }

    void sort_() {
        for (int i = 1; i <= n; i++) {
            sort(data[i].begin(), data[i].end());
        }
    }

    void add(int a, int b) {
        data[a].push_back(b);
        data[b].push_back(a);
        grad[a]++;
        grad[b]++;
    }

    bool isEulerian() {
        if (!isConnex()) {
            return false;
        }
        for (int i = 1; i <= n; i++) {
            if (grad[i] % 2 == 1) {
                return false;
            }
        }
        return true;
    }

    vector<int> printSolution() {
        vector<int> sol;
        vector<int> stack_a;
        stack_a.push_back(1);

        while (stack_a.size() > 0) {
            int a = stack_a.back();
            bool gata = true;
            while (data[a].size() > 0) {
                int c = data[a].back();
                data[a].pop_back();
                if (c > n) {
                    continue;
                }
                if (binary_search(data[c].begin(), data[c].end(), a)) {
                    vector<int>::iterator lb =
                            lower_bound(data[c].begin(), data[c].end(), a);
                    data[c][ lb - data[c].begin() ] = 1000000;
                    stack_a.push_back(c);
                    gata = false;
                    break;
                }
            }

            if (gata) {
                sol.push_back(a);
                stack_a.pop_back();
            }
        }
        return sol;

    }

    bool isConnex() {
        vector<int> v;
        bool *marcat = new bool[n + 1];
        for (int i = 0; i <= n; i++) {
            marcat[i] = false;
        }
        marcat[1] = true;
        v.push_back(1);
        int op = 0;
        while (v.size() > 0) {
            op++;
            int current = v.back();
            v.pop_back();
            for (int i = 0; i < data[current].size(); i++) {
                int next = data[current][i];
                if (!marcat[next]) {
                    v.push_back(next);
                    marcat[next] = true;
                }
            }
        }
        return op == n;
    }

};

/*
 * 
 */
int main(int argc, char** argv) {

    ifstream input("ciclueuler.in");
    ofstream output("ciclueuler.out");

    int n, m;
    input >> n >> m;
    Graf g(n);
    for (int i = 0; i < m; i++) {
        int a, b;
        input >> a >> b;
        g.add(a, b);
        // g.add( b, a );
    }
    g.sort_();

    if (g.isConnex()) {
        vector<int> sol = g.printSolution();
        for (int i = 0; i < sol.size() - 1; i++) {
            //cout << sol[i] << endl;
            output << sol[i] << " ";
        }
    } else {
        output << "-1";
    }
    output.flush();
    return 0;
}