#include <iostream>
#include <fstream>
#include <queue>
#include <stack>

using namespace std;

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

struct nod
{
    int info;
    nod *urm;
}*L[100001];

int n, m, grad[100001];
bool fr[100001];
queue <int> q;

void adauga(int i, int j)
{
    nod *p=new nod;
    p->info=j;
    p->urm=L[i];
    L[i]=p;
}

void stergere(int i, int j)
{
    if(L[i]->info==j)
        L[i]=L[i]->urm;
    else
    {
        nod *p=L[i];
        while(p->urm)
        {
            if(p->urm->info==j){
                p->urm=p->urm->urm;
                return;
            }
            p=p->urm;
        }
    }
}

void citire()
{
    fin>>n>>m;
    int x, y;
    for(int i=1;i<=m;i++)
    {
        fin>>x>>y;
        adauga(x,y);
        adauga(y,x);
        grad[x]++;
        grad[y]++;
    }
    fin.close();
}

void dfs(int poz)
{
    fr[poz]=true;
    for(nod *p=L[poz];p!=NULL;p=p->urm)
    {
        if(fr[p->info]==false)
            dfs(p->info);
    }
}

bool verif_euler()
{
    for(int i=1;i<=n;i++)
        if(grad[i]%2==1)
            return false;
    return true;
}

bool verif_conex()
{
    dfs(1);
    for(int i=1;i<=n;i++)
        if(fr[i]==false)
            return false;
    return true;
}

void euler(int poz)
{

    while(L[poz]!=NULL)
    {
        int x=L[poz]->info;
        stergere(poz,x);
        stergere(x,poz);
        euler(x);
    }
    q.push(poz);
}

void rezolvare()
{
    if(verif_conex() and verif_euler())
    {
        euler(1);
        while(!q.empty())
        {
            if(q.size()>=2)
                fout<<q.front()<<' ';
            q.pop();
        }
    }
    else
        fout<<-1;
    fout.close();
}
int main()
{
    citire();
    rezolvare();
    return 0;
}