#include <fstream>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <bitset>
#include <set>

using namespace std;

multiset < int > G [ 100001 ];
int deg [ 100001 ];
bitset <100001> u;
queue <int> q;
int n, m;
stack <int> c, s;

void bfs (){

    int n;
    multiset <int> :: iterator it;

    q . push ( 1 );
    u . set ( 1 );

    while ( ! q . empty () ){
        n = q . front ();
        q . pop ();
        for ( it = G [ n ] . begin (); it != G [ n ] . end (); ++ it )
            if ( ! u [ * it ] ){
                q . push ( * it );
                u . set ( * it );
            }
    }

}

bool connected (){

    bfs (  );

    for ( int i = 1; i <= n; ++ i )
        if ( ! u [ i ] && G [ i ] . size () > 0 )
            return false;

    return true;

}

bool eulerian (){

    if ( ! connected () )
            return false;
    for ( int i = 1; i <= n; ++ i )
        if ( deg [ i ] & 1 )
            return false;
    return true;

}

void euler (int n){

    //cout << n << "\n";

    multiset < int > :: iterator i, j;
    int e;

    do{
        if ( G [ n ] . size () == 0 ){
            c . push ( n );
            n = s . top (  );
            s.pop();

        }
        else{
            i = G [ n ] . begin ();//muchia
            e = *i;
            G [ n ] . erase ( i );
            j = G [ e ] . find ( n );
            G [ e ] . erase ( j );
            s . push (n);
            n = e;
        }
    }while ( !s.empty() );
}

void print ( ofstream *g ){
    while ( ! c . empty () ){
        * g << c . top () << " ";
        c . pop ();
    }
    * g << "\n";
}

int main()
{

    int i, x, y;
    ifstream f ( "ciclueuler.in" );
    ofstream g ( "ciclueuler.out" );
    f >> n >> m;
    for ( i = 0; i < m; ++ i ){
        f >> x >> y;
        ++ deg [ x ];
        ++ deg [ y ];
        G [ x ] . insert ( y );
        G [ y ] . insert ( x );
    }
    f.close();

    if ( !eulerian () ){
        g << "-1\n";
        g . close();
        return 0;
    }
    else{
        euler(1);
        print(&g);
        g . close();
    }

    return 0;
}