#include <iostream>
#include <fstream>
#include <vector>
#include <stack>

using namespace std;

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

class Graf
{
    int numar_noduri, numar_muchii;
    vector <vector <int>> lista_adiacenta;

public:

    void ciclu_eulerian();
};

void Graf :: ciclu_eulerian()
{
    int capat_stang, capat_drept, ok = 1;

    fin >> numar_noduri >> numar_muchii;

    int v1[numar_muchii], v2[numar_muchii];
    int vizitat[numar_muchii] = {};

    lista_adiacenta.resize(numar_noduri + 1);

    for(int i = 0; i < numar_muchii; i++)
    {
        fin >> capat_stang >> capat_drept;

        lista_adiacenta[capat_stang].push_back(capat_drept);
        lista_adiacenta[capat_drept].push_back(capat_stang);

        v1[i] = capat_stang;
        v2[i] = capat_drept;
    }

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

    if(ok)
    {
        int nod, x;
        stack <int> noduri;
        vector <int> euler;

        noduri.push(1);

        while(!noduri.empty())
        {
            nod = noduri.top();

            if(lista_adiacenta[nod].size())
            {
                x = lista_adiacenta[nod].back();
                lista_adiacenta[nod].pop_back();

                if(!vizitat[x])
                {
                    if(v1[x] != nod)
                        noduri.push(v1[x]);
                    else
                        noduri.push(v2[x]);
                    vizitat[x] = 1;
                }
            }
            else
            {
                euler.push_back(nod);
                noduri.pop();
            }
        }

        euler.pop_back();

        for(int i = 0; i < euler.size(); i++)
            fout << euler[i] << " ";
    }

    lista_adiacenta.clear();
}

int main()
{
    Graf x;
    x.ciclu_eulerian();

    fin.close();
    fout.close();

    return 0;
}