#include <bits/stdc++.h>

//#define fin std::cin
//#define fout std::cout

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

/*
    -> Ciclu eulerian = un ciclu care sa treaca prin toate muchiile
    Obs: Se trece prin fiecare nod intrand si iesind, adica gradul trebuie sa fie par
    la toate nodurie
    Obs: Daca avem mai multe componente conexe, atunci nu are cum sa existe un ciclu
    eulerian, numai daca componentele conexe "exterioare" sunt noduri izolate. (dar nu se intampla)

*/

const int nmax = 1e5 + 5;

int n, m;
std::vector<std::pair<int, int>> graph[nmax];
bool visited[nmax];
int deg[nmax];

int currentEdge[nmax], visitedEdges[5 * nmax];
std::vector<int> cycle;

void buildVisited(int node)
{
    for(auto x : graph[node])
        if(!visited[x.first])
        {
            visited[x.first] = true;
            buildVisited(x.first);
        }
}

void buildCycle(int node)
{
    while(currentEdge[node] < graph[node].size()) // mai am vecini de procesat
    {
        if(visitedEdges[graph[node][currentEdge[node]].second]) // am vizitat aceasta muchie
        {
            currentEdge[node]++;
        }
        else
        {
            // o vizitam, trecem la urmatoarea si mergem in nodul adiacent
            visitedEdges[graph[node][currentEdge[node]].second] = true;
            int adj = graph[node][currentEdge[node]].first;
            currentEdge[node]++;
            buildCycle(adj);
        }
    }
    cycle.push_back(node); // inseram in ciclu
}

int main()
{
    fin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        int x, y;
        fin >> x >> y;
        graph[x].push_back({y, i});
        graph[y].push_back({x, i});
        deg[x]++;
        deg[y]++;
    }

    visited[1] = true;
    buildVisited(1);

    for(int i = 1; i <= n; ++i)
        if(!visited[i] || deg[i] % 2)
        {
            fout << -1 << "\n";
            return 0;
        }

    buildCycle(1);
    
    for(auto x : cycle)
        fout << x << " ";

    return 0;
}