#include<fstream>
#include<list>
#define NMAX 100010

using namespace std;

ifstream f("ciclueuler.in");
ofstream g("ciclueuler.out");

list<int> a[NMAX];
int n, m, d[NMAX], vz[NMAX];
struct nod
{
    int x;
    nod * urm;
}*ciclu, *uciclu, *c, *cu, *q;

void Citeste()
{
    int x, y;

    f>>n>>m;
    while (m--)
    {
        f>>x>>y;
        a[x].push_back(y); ++d[x];
        a[y].push_back(x); ++d[y];
    }
}

void DFS(int nod)
{
    list<int> :: iterator it;
    vz[nod]=1;
    for (it=a[nod].begin(); it!=a[nod].end(); ++it)
        if (!vz[*it]) DFS(*it);
}

bool bun()
{
    int i;
    DFS(1);
    for (i=1; i<=n; ++i)
        if (d[i]%2==1 || (d[i]>0 && !vz[i])) return 0;
    return 1;
}

void Ciclu(int start, int x)
{
    list<int> :: iterator it, aux;
    int inf;
    nod *q;

    if (start!=x || c==NULL)
    {
        --d[x];
        if (c==NULL) {c=new nod; cu=c; c->x=x; c->urm=NULL;}
        else {q=new nod; q->x=x; q->urm=NULL; cu->urm=q; cu=q;}

        aux=a[x].begin(); --d[*aux];
        inf=*aux; a[x].erase(aux);
        for (it=a[inf].begin(); it!=a[inf].end(); ++it)
            if ((*it)==x) break;
        a[inf].erase(it);
        Ciclu(start, inf);
    }
}

void Afis()
{
    while(ciclu)
    {
        g<<ciclu->x<<" ";
        ciclu=ciclu->urm;
    }
}

void Solve()
{
    int x=1;
    nod *aux, *nex;
    if (! bun() ) g<<"-1\n";
    else
    {
        while (!d[x]) ++x;
        c=NULL; Ciclu(x, x);
        ciclu=c; uciclu=cu;
        q=new nod; q->x=x; q->urm=NULL; uciclu->urm=q; uciclu=q;
        q=ciclu;
        while (q)
        {
            x=q->x;
            if (d[x])
            {
                c=NULL;
                Ciclu(x, x);
                aux=new nod; aux->x=x; aux->urm=NULL; cu->urm=aux; cu=aux;
                nex=q->urm; c=c->urm;
                q->urm=c; cu->urm=nex;
            }
            q=q->urm;
        }
        Afis();
    }
}

int main()
{
    Citeste();

    Solve();

    f.close();
    g.close();
    return 0;
}