#include <cstdio>

using namespace std;

struct noduri
{
    int nod;
    noduri *urm;
}*v[100001],*v_u[100001];

noduri *primul,*ultimul,*ultimul_ultim;

int ciclu_eulerian[500001];
int grad[100001],grad1;

void afiseaza_muchii(noduri *p)
{
    while (p->urm)
    {
        printf("%d ",p->nod);
        p=p->urm;
    }
}

void merge_ultimul(int x)
{
    ultimul=primul;
    while (ultimul->nod!=x)
        ultimul=ultimul->urm;
}

int main()
{
    freopen("ciclueuler.in","r",stdin);
    freopen("ciclueuler.out","w",stdout);
    int n,m;
    scanf("%d %d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d %d\n",&a,&b);

        grad[a]++;
        grad[b]++;

        if (a!=b)
        {
            if (grad[a]%2==0) grad1--;
            else grad1++;

            if (grad[b]%2==0) grad1--;
            else grad1++;
        }

        if (v[a]==NULL)
        {
            noduri *p;
            p=new noduri;
            p->nod=b;
            p->urm=NULL;
            v[a]=p;
            v_u[a]=p;
        }
        else
        {
            noduri *p;
            p=new noduri;
            p->nod=b;
            p->urm=NULL;
            v_u[a]->urm=p;
            v_u[a]=p;
        }
        if (v[b]==NULL)
        {
            noduri *p;
            p=new noduri;
            p->nod=a;
            p->urm=NULL;
            v[b]=p;
            v_u[b]=p;
        }
        else
        {
            noduri *p;
            p=new noduri;
            p->nod=a;
            p->urm=NULL;
            v_u[b]->urm=p;
            v_u[b]=p;
        }
    }
    if (grad1!=0) printf("-1");
    else
    {

    /// alegerea nodului de inceput
    int x=0,x0=0;
    while (grad[x0]==0)
        x0++;

    x=x0;

    primul=new noduri;
    primul->nod=x;
    primul->urm=NULL;
    ultimul=primul;

    ultimul_ultim=NULL;

    while (grad[x0])
    {
        x=x0;
        while (v[x])
        {
            /// adaugarea nodului in lista

            noduri *p0;
            p0=new noduri;
            p0->nod=v[x]->nod;
            p0->urm=ultimul_ultim;
            ultimul->urm=p0;
            ultimul=p0;

            if (x==v[x]->nod)
            {
                noduri *p2=v[x];
                v[x]=v[x]->urm;
                delete p2;
                p2=v[x];
                v[x]=v[x]->urm;
                delete p2;

                if (v[x]==NULL) grad[x]=0;
                ///grad[x]=-1;
            }
            else
            {
                int y=v[x]->nod;
                noduri *p=v[y]->urm;
                noduri *p1=v[y];

                noduri *p2=v[x];
                v[x]=v[x]->urm;
                delete p2;

                if (v[x]==NULL) grad[x]=0;
                ///grad[x]=-1;

                if (p1->nod==x)
                {
                    v[y]=v[y]->urm;
                    delete p1;

                    if (v[y]==NULL) grad[y]=0;
                    ///grad[y]=-1;
                }
                else
                {
                    int a1=1;
                    while (a1)
                    {
                        if (p->nod==x)
                        {
                            p1->urm=p->urm;
                            delete p;
                            a1=0;
                        }
                        else
                        {
                            p1=p1->urm;
                            p=p->urm;
                        }
                    }
                }
                x=y;
            }
        }
        while (grad[x0]==0 && x0<=n-1)
            x0++;
        merge_ultimul(x0);
        ultimul_ultim=ultimul->urm;
    }
    afiseaza_muchii(primul);
    }
}