#include <fstream>
#include <algorithm>
#include <vector>
#include <stack>
#include <cstring>

#define DIM 100005
#define vint vector<int>::iterator
#define pint vector< pair<int, int> >::iterator
#define ERROR_MESSAGE "-1\n"
#define infile "ciclueuler.in"
#define outfile "ciclueuler.out"

using namespace std;

ifstream f(infile);
ofstream g(outfile);

int n, m;

int entriesCount = 0;

vector< pair<int, int> > L[DIM];

stack<int> nodeStack;

bool ok[5 * DIM];

int nodeGrade[DIM];

void dfs(int node) {

    ok[node] = true;

    for (pint it = L[node].begin(); it != L[node].end(); ++it) {

        ++entriesCount;

        if (ok[it->first])
            continue;

        dfs(it->first);

    }

}

void getEulerCicle() {

    nodeStack.push(1);

    for (; !nodeStack.empty();) {


        int node = nodeStack.top();

        while (!L[node].empty()) {

            pair<int, int> edge = *L[node].rbegin();

            if (ok[edge.second] == false)
                break;

            L[node].pop_back();

        }

        if (!L[node].empty()) {

            nodeStack.push( L[node].rbegin()->first );

            ok[ L[node].rbegin()->second ] = true;

            L[node].pop_back();

            continue;

        }

        g << nodeStack.top() << ' ';

        nodeStack.pop();

    }

}

int main() {

    f >> n >> m;

    for (int i = 1; i <= m; ++i) {

        int x, y;

        f >> x >> y;

        ++nodeGrade[x];
        ++nodeGrade[y];

        L[x].push_back( make_pair(y, i) );
        L[y].push_back( make_pair(x, i) );

    }

    for (int i = 1; i <= n; ++i)
        if (nodeGrade[i] % 2 == 1) {

            g << ERROR_MESSAGE;
            return 0;

        }

    memset(ok, false, sizeof(ok));

    for (int i = 1; i <= n; ++i)
        if (!ok[i])
            dfs(i);

    if (entriesCount != 2 * m) {

        g << ERROR_MESSAGE;
        return 0;

    }

    memset(ok, false, sizeof(ok));

    getEulerCicle();

    return 0;
}