#include <cstdio>
#include<vector>
using namespace std;

int m,n;
int d[100005];
vector<int> g[100005];
bool viz[100005];

struct nod{int vf;
            nod* urm;
};

typedef struct nod* lista;

lista c1,c2,sfc1,sfc2;

void afisare(){

    lista p;
    for(p=c1;p->urm!=NULL;p=p->urm)
        printf("%d ",p->vf);

}

void dfs(int x){

    viz[x]=1;
    for(int j=0;j<g[x].size();++j){

        if(!viz[g[x][j]]){

            dfs(g[x][j]);

        }

    }
}

int gradepare(){

    for(int i=1;i<=n;++i){

        if(d[i]%2){

            return 0;

        }
    }
    return 1;

}

void citire(){
    int x,y;
    scanf("%d%d",&n,&m);

    for(int i=1;i<=m;++i){

        scanf("%d%d",&x,&y);

        g[x].push_back(y);
        g[y].push_back(x);
        d[x]++;
        d[y]++;

    }

}
bool conex(){
    int x;
    for( x=1;x<=n && !d[x];++x);

    if(x>n) return 1;
    dfs(x);
    for(int x=1;x<=n;++x)//verific daca au mai ramas vf neviz si neizolate
        if(!viz[x] && d[x])
            return 0;
    return 1;

}

int ciclu(int x,lista &c,lista &sfc){
    int y,uvf,lg=0,i,dim;
    lista p;
    //incep ciclul cu vf x;
    p=new nod;
    p->urm=NULL;
    p->vf=x;
    c=p;
    sfc=p;

    do
    {

        //caut y un vf ad cu ultimul vf din lista
        //parcurg linia uvf pana dau de un
        uvf=sfc->vf;
        for(i=0;!g[uvf][i] && i<g[uvf].size();++i);
        y=g[uvf][i];
        p=new nod;
        p->vf=y;
        p->urm=NULL;
        sfc->urm=p;
        sfc=p;
        ++lg;

        g[uvf][i]=0;
        for(i=0;i<g[y].size();++i)
            if(g[y][i]==uvf){

                g[y][i]=0;
                break;

            }
        d[y]--;
        d[uvf]--;

    }
    while(y!=x);

    return lg;

}
void determina_eulerian(){
    int i,nr2,total=0;
    lista p,q;
    //caut un vf cu gradul nenul;
    for(i=1;i<=n && !d[i];++i);

    total=ciclu(i,c1,sfc1);

    while(total<m){
        //caut pe c1 un vf cu gradul nenul

        for(p=c1;!d[p->vf];p=p->urm);
        nr2=ciclu(p->vf,c2,sfc2);
        //reunesc ciclul c1 cu c2
        q=p->urm;

        p->urm=c2->urm;

        sfc2->urm=q;

        total+=nr2;
    }

}
int main()
{
    freopen("ciclueuler.in","r",stdin);
    freopen("ciclueuler.out","w",stdout);

    citire();

    if(conex() && gradepare()){

        determina_eulerian();
        afisare();
    }
    else{

        printf("-1");

    }



    return 0;
}

/*
#include <fstream>
using namespace std;

ifstream fin("euler.in");
ofstream fout("euler.out");

int n, m;
int G[101][101],d[100000];

struct nod
{
    int x;
    struct nod * urm;
};
typedef nod * lista;

lista C1,C2,sfc1,sfc2;

void citire();
void euler();
void afisare();
int ciclu(int st, lista & C, lista & sf);
lista cauta();

int main()
{
    int total=0,nr;
    lista p,q;
    citire();
    // construim primul ciclu
    total+=ciclu(1,C1,sfc1);
    while(total<m) //mai am muchii care nu apartin ciclului
    {
        //caut un varf care apartine lui C1 incident cu o muchie care nu apartine lui C1
        p=cauta();
        nr=ciclu(p->x, C2, sfc2);
        //unific C1 cu C2
        q=p->urm;
        p->urm=C2->urm;
        sfc2->urm=q;
        total+=nr;
    }
    afisare();
    return 0;
}

void citire()
{
    int i,a,b;
    fin>>n>>m;
    for(i=1;i<=m;i++)
    {
        fin>>a>>b;
        if(a!=b){
        G[a][++G[a][0]]=b;
        ++d[a];
        G[b][++G[b][0]]=a;
        ++d[b];
        }
        else{

            G[a][++G[a][0]]=a;
            ++d[a];
        }
    }
}

int ciclu(int st,lista & C,lista & sf)
{
    int vf,i,nr=0,nou;
    lista p;
    p=new nod;
    p->x=st;
    p->urm=NULL;
    C=sf=p;
    //construiesc ciclul
    do
    {
        vf=sf->x;
        for(i=1;i<=G[vf][0];i++)
            if(G[vf][i]!=0)
                break;
        // creez un nod cu informatia i si il inserez la sfarsitul listei C
        nou=G[vf][i];
        p=new nod;
        p->x=nou;
        p->urm=NULL;
        sf->urm=p;
        sf=p;
        nr++;
        //elimin din graf muchia vf i
        G[vf][i]=0;
        --d[vf];
        for(int j=1;j<=G[i][0];++j){

            if(G[nou][j]==vf){
                G[nou][j]=0;
                --d[nou];
                break;
            }
        }

    }
    while(nou!=st);
    return nr;
}

lista cauta()
{
    int i;
    lista p;
    // caut in lista C1 un nod care mai are muchii incidente cu el
    for(p=C1;p!=NULL;p=p->urm)
        if(d[p->x])
        return p;
}

void afisare()
{
    lista p;
    for(p=C1;p->urm!=NULL;p=p->urm)
        fout << p->x << ' ';
    fout<<'\n';
    fout.close();
}
*/