type pnod=^nod;
     nod = record
        info : longint;
        next : pnod;
end;
const f = 'ciclueuler.in'; gg = 'ciclueuler.out';
const max_n = 100000;
      max_m = 500000;
var
    c : array[0..max_m] of pnod;
    v, sol : array[0..max_n] of longint;
    viz : array[0..max_n] of byte;
    n, m, nc : longint;
    //g : array[0..10000,0..10000] of byte;
    a, b, vf, i, x, y : longint;

procedure add( var dest : pnod; val : longint );
    var
        q : pnod;
    begin
        new( q );
        q^.next := dest;
        q^.info := val;
        dest := q;
    end;

procedure del( x, y : longint );
    var
        q, p : pnod;
    begin
        q := c[x];
        c[x] := c[x]^.next;
        dispose( q );
        if c[y]^.info = x then begin
            q := c[y];
            c[y] := c[y]^.next;
            dispose( q );
        end
        else begin
        q := c[y];
        while q^.next^.info<> x do q := q^.next;
        p := q^.next;
        q^.next := p^.next;
        dispose( p );
        end;
    end;

begin
    assign( input,f ); reset( input );
    assign( output,gg ); rewrite( output );
    readln( n, m );
    for i := 1 to m do begin
        readln( x,y );
        add(c[x],y);
        add(c[y],x);
    end;
    vf := 1;
    v[vf] := 1;
    while vf <> 0 do begin
        a := v[vf];
        if (c[a] <> nil )  then begin
            //viz[c[a]^.info] := 1;
            //viz[v[a]] := 1;
            inc( vf );
            v[vf] := c[a]^.info;
            del(a,c[a]^.info);
        end
        else begin
             inc( b );
             //viz[v[a]] := 1;
             sol[b] := v[vf];
             dec( vf );
             end;
    end;
    for i := 1 to b-1 do write(sol[i],' ');


end.