type
     edge=record
      x,y:longint;
     end;
var
   edges:array[1..50010] of edge;
   adiacenta:array[1..10001,1..10001] of longint;
   degree,lista:array[1..10001] of longint;
   i,j,m,n,noduri,muchii,neigh,u,k,grade:longint;
   Queue,Visited,st:array[1..100001] of 0..100001;

function next(x:longint):longint;
var i,j:longint;
begin
     for i:=1 to muchii do
     if edges[i].x=x then
     begin
          next:=edges[i].y;
          exit;
     end;

     for i:=1 to muchii do
     if edges[i].y=x then
     begin
          next:=edges[i].x;
          exit;
     end;


end;

procedure erase(a,b:longint);
var i,j:longint;
begin
     for i:=1 to muchii do
     if (edges[i].x=a) and (edges[i].y=b) then
     begin
          edges[i].x:=0;
          edges[i].y:=0;
          break;
     end;
     for j:=i to muchii do
     begin
          edges[j].x:=edges[j+1].x;
          edges[j].y:=edges[j+1].y;
     end;
     dec(muchii);
     fillchar(degree,sizeof(degree),0);
     for i:=1 to noduri do
    begin
        for j:=1 to muchii do
        if (edges[j].x=i) or (edges[j].y=i) then inc(degree[i]);
    end;
end;
procedure push(n:longint);

begin
    lista[k]:=n;
    inc(k);
end;

procedure push_st(nod:longint);
begin
    inc(u);
    st[u]:=nod;
end;

procedure pop;
begin
   st[u]:=0;
   dec(u);
end;

//Cautare ciclu eulerian
procedure Euler(nod:longint);
var w,neigh:longint;
begin
    push_st(nod);
    while u>0 do
    begin
        nod:=st[u];
        if degree[nod]=0 then
        begin
           push(nod);
           pop;
        end
         else
         begin
              neigh:=next(nod);
              erase(nod,neigh);
              push_st(neigh);
         end;
    end;

end;
{

procedure Euler(nod:longint);
begin
    while (degree[nod]>0) do
    begin
        neigh:=next(nod);
        erase(nod,neigh);
        euler(neigh);
    end;
    push(nod);
end;
      }
//Parcurgere in adancime
function dfs(n:longint):boolean;
var i,p,u,v:longint;
   // Queue,Visited:array[1..10001] of longint;
begin
     fillchar(Visited,sizeof(Visited),0);
     p:=1;
     u:=1;
     queue[1]:=1; visited[1]:=1;
     while p<=u do
     begin
          v:=queue[p]; inc(p);
          for i:=1 to n do
          if (adiacenta[v,i]=1) and (visited[i]=0) then
          begin
             inc(u);
             queue[u]:=i;
             visited[i]:=1;
          end;

     end;
     dfs:=true;
     for i:=1 to n do
     if visited[i]=0 then dfs:=not(dfs);
end;

{procedure dfs(nod:longint);
var k:longint;
begin
    //write(nod);
    visited[nod]:=1;
    for k:=1 to noduri do
    if (adiacenta[nod,k]=1) and (visited[k]=0) then
    dfs(k);
end; }



BEGIN
    assign(input,'ciclueuler.in'); reset(input);
    assign(output,'ciclueuler.out'); rewrite(output);
    readln(input,noduri,muchii);
    for i:=1 to muchii do
    readln(input,edges[i].x,edges[i].y);
    fillchar(adiacenta,sizeof(adiacenta),0);
    for i:=1 to muchii do
    adiacenta[edges[i].x,edges[i].y]:=1;
    fillchar(degree,sizeof(degree),0);
    u:=0; k:=1;
    fillchar(lista,sizeof(lista),0);
    for i:=1 to noduri do
    begin
        for j:=1 to muchii do
        if (edges[j].x=i) or (edges[j].y=i) then
        begin
           if edges[j].x<>edges[j].y then
           inc(degree[i]);
        end;
    end;
    for i:=1 to noduri do if odd(degree[i]) then
    begin
       write(output,'-1');
       exit;
    end;

    if not(dfs(1)) then
    begin
         write(output,'-1');
         exit;
    end;

    Euler(1);
    for i:=k-1 downto 2 do write(output,lista[i],' ');
    close(input);
    close(output);
END.