#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;

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

    for(int i = 1; i <= numar_noduri; i++)
        if(lista_adiacenta[i].size() % 2 || !lista_adiacenta[i].size())
    {
        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();
                noduri.push(x);
                lista_adiacenta[nod].pop_back();

                int i;
                for(i = 0; i < lista_adiacenta[x].size(); i++)
                    if(lista_adiacenta[x][i] == nod)
                        break;
                lista_adiacenta[x].erase(lista_adiacenta[x].begin() + i);

        }
        else
        {
            euler.push_back(nod);
            noduri.pop();
        }
    }

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

    lista_adiacenta.clear();

}

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

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

    return 0;
}