#include <fstream>
#include <vector>
#include <stack>
#define NMAX 100002
#define MMAX 500002

using namespace std;

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

struct varf
{
    int x, nr;
}; ///x este vf adiacent, nr este nr muchiei corespunzatoare
int n, m;
vector<varf> g[NMAX];
bool uz[MMAX]; ///uz[i]=1 daca muchia cu nr de ord i a fost ut pe ciclu
int d[NMAX];
stack<int> s;

void citire();
int grade_pare();
void euler(int start);

int main()
{
    int eulerian, i, start;
    citire();
    if(!(start=grade_pare()))
        fout << -1 << ' ';
    else
    {
        euler(start);
        eulerian=1;
        for(i=1; i<=m; i++)
            if(!uz[i]) eulerian=0;
        if(!eulerian)
        {
            fout.close();
            fout.open("ciclueuler.out");
            fout << -1 << ' ';
        }
    }
    return 0;
}

void citire()
{
    int i, x, y;
    varf vf;
    fin >> n >> m;
    for(i=1; i<=m; i++)
    {
        fin >> x >> y;
        ///y intra in l.a. a lui x
        vf.x=y;
        vf.nr=i;
        g[x].push_back(vf);
        ///x intra in l.a. a lui y
        vf.x=x;
        vf.nr=i;
        g[y].push_back(vf);
        d[x]++;
        d[y]++;
    }
}

int grade_pare()
{
    ///ret 0 daca nu toate gradele sunt pare
///daca gradele sunt toate pare ret indicile unui vf care nu este izolat
    int i, start;

    for(i=1; i<=n; i++)
    {
        if(d[i]%2) return 0;
        if(d[i]) start=i;
    }
    return start;
}

void euler(int start)
{
    varf vfad;
    int vf;
    s.push(start);
    while(!s.empty())
    {
        vf=s.top();
        ///aleg un varf ad cu vf
        if(!g[vf].empty())
        {
            vfad=g[vf][g[vf].size()-1];
            if(!uz[vfad.nr])///muchie neut.
            {
                uz[vfad.nr]=1;
                s.push(vfad.x);
            }
            g[vf].pop_back();
        }
        else
        {
            fout<<vf<< ' ' ;
            s.pop();
        }
    }

}