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

using namespace std;

bool viz[500100];
int n, m, X[500100], Y[500100], sol[500100], nsol;
vector <int> G[100010];
stack < pair<int, vector <int>::iterator> > st;

inline void Read()
{
    ifstream f("ciclueuler.in");
    f>>n>>m;
    int i;
    for (i=1; i<=m; i++)
    {
        f>>X[i]>>Y[i];
        G[X[i]].push_back(i);
        G[Y[i]].push_back(i);
    }
    f.close();
}

inline bool Verificare()
{
    for (int i=1; i<=n; i++)
        if (G[i].size() & 1)
            return true;
    return false;
}

inline void DFS(int nod)
{
    vector <int>::iterator it;
    for (it = G[nod].begin(); it!=G[nod].end(); it++)
    {
        if (!viz[*it])
        {
            viz[*it] = true;
            DFS(X[*it] + Y[*it] - nod);
        }
    }
    sol[++nsol] = nod;
}

inline void Solve()
{
    //DFS(1);

    vector <int>::iterator it;
    pair<int, vector <int>::iterator> aux, aux2;
    int nod;
    aux.first = 1;
    aux.second = G[1].begin();
    st.push(aux);
    while (!st.empty())
    {
        aux = st.top();
        nod = aux.first;
        it = aux.second;
        if (it == G[nod].end())
        {
            st.pop();
            sol[++nsol] = nod;
        }
        else
        {
            if (!viz[*it])
            {
                viz[*it] = true;

                aux2.first = X[*it] + Y[*it] - nod;
                aux2.second = G[X[*it] + Y[*it] - nod].begin();

                st.pop();
                it++;
                aux.first = nod;
                aux.second = it;

                st.push(aux);
                st.push(aux2);
            }
            else
            {
                st.pop();
                it++;
                aux.first = nod;
                aux.second = it;
                st.push(aux);
            }
        }
    }

}

inline void Write()
{
    ofstream g("ciclueuler.out");
    int i;
    for (i=1; i<=nsol; i++)
        g<<sol[i]<<" ";
    g<<"\n";
    g.close();
}

int main()
{
    Read();
    if (Verificare())
    {
        ofstream g("ciclueuler.out");
        g<<"-1\n";
        g.close();
        return 0;
    }
    Solve();
    Write();
    return 0;
}