#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 currentEdge[5 * nmax], visitedEdges[5 * nmax];
std::vector<int> cycle;

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

void buildCycle(int node)
{
    while(currentEdge[node] < graph[node].size())
    {
        if(visitedEdges[graph[node][currentEdge[node]].second])
        {
            currentEdge[node]++;
        }
        else
        {
            visitedEdges[graph[node][currentEdge[node]].second] = true;
            int adj = graph[node][currentEdge[node]].first;
            currentEdge[node]++;
            buildCycle(adj);
        }
    }
    cycle.push_back(node);
}

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});
    }

    int compCount = 0;
    for(int i = 1; i <= n; ++i)
        if(!visited[i])
        {
            compCount++;
            visited[i] = true;
            buildVisited(i);
        }
    
    if(compCount > 1)
    {
        fout << -1 << "\n";
        return 0;
    }

    for(int i = 1; i <= n; ++i)
        if(graph[i].size() % 2)
        {
            fout << -1 << "\n";
            return 0;
        }

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

    return 0;
}