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

using namespace std;

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

struct muchie
{
    int nod, vz;
};

struct entitate
{
    int nod;
    entitate *urm;
}*c, *c1, *p, *ultim, *ultim1;

vector<muchie> a[NMAX];

int d[NMAX], vz[NMAX], lg[NMAX], n, m;

void Citeste()
{
    int i, x, y;
    muchie r;
    f>>n>>m;
    r.vz=0;
    for (i=1; i<=m; ++i)
    {
        f>>x>>y;
        ++d[x]; ++d[y]; ++lg[x]; ++lg[y];
        r.nod=y;
        a[x].push_back(r);
        r.nod=x;
        a[y].push_back(r);
    }
}

void DFS(int nod)
{
    int i;
    muchie r;
    vz[nod]=1;
    for (i=0; i<d[nod]; ++i)
    {
        r=a[nod][i];
        if (!vz[r.nod]) DFS(r.nod);
    }
}

int graf_eulrian()
{
    int i, sg=0, pv=1;
    DFS(1);
    for (i=1; i<=n; ++i)
    {
        sg+=d[i]%2;
        pv*=vz[i];
    }
    if (pv==0 || sg>0) return 0;
    return 1;
}

int Next(int nod)
{
    int i, j, x;

    for (i=0; i<lg[nod]; ++i)
        if (!a[nod][i].vz)
        {
            a[nod][i].vz=1;
            x=a[nod][i].nod;
            for (j=0; j<lg[x]; ++j)
                if (a[x][j].nod==nod && !a[x][j].vz)
                {
                    a[x][j].vz=1;
                    break;
                }
            return x;
        }
}

void Construieste(int nod, entitate* &c, entitate* &ultim)
{
    int urm;
    entitate *q;

    c=new entitate;
    c->urm=NULL;
    c->nod=nod;
    ultim=c;//--d[nod];
    do
    {
        --d[ultim->nod];
        urm=Next(ultim->nod);
        q=new entitate; q->urm=NULL;
        q->nod=urm;
        d[urm]--;
        ultim->urm=q; ultim=q;
    }while(nod!=urm);
}

void Scrie()
{
    while (c!=NULL)
    {
        g<<c->nod<<" ";
        c=c->urm;
    }
}

void Solve()
{
    Construieste(1, c, ultim);
    p=c;

    while ((p->urm)!=NULL)
    {
        if (d[p->nod]>0)
        {
            Construieste(p->nod, c1, ultim1);
            ultim1->urm=p->urm;
            p->urm=c1->urm;
        }
        p=p->urm;
    }

}

int main()
{
    Citeste();
    if (graf_eulrian())
    {
        Solve();
        Scrie();
    }
    else g<<"-1";
    f.close();
    g.close();
    return 0;
}