#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 << '\n';
    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 << '\n';
           }
       }
    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();}
               }

}