#include <fstream>
#include <queue>
#include <stack>
#include <vector>
using namespace std;

ifstream is("ciclueuler.in");
ofstream os("ciclueuler.out");

int N, M, x, y, o;
bool Vis[100001];

vector <int> G[100001], Sol;
queue <int> Q;
stack <int> S;

void Input();
bool Conex();
bool Eulerian();
void DFS(int v);
void Delete(int x, int y);

int main()
{
    Input();
    if ( !Eulerian() )
    {
        os << -1;
        return 0;
    }
    o = 1;
    do {
        DFS(o);
        o = S.top();
        S.pop();
        Sol.push_back(o);
    } while ( !S.empty() );

    for ( int i = Sol.size()-1 ; i >= 0; --i )
        os << Sol[i] << " ";



    is.close();
    os.close();
}

void Input()
{
    is >> N >> M;
    for ( int i = 1; i <= M; ++i )
    {
        is >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
}

bool Conex()
{
    Q.push(1);  int nod;
    Vis[1] = 1;
    while ( !Q.empty() )
    {
        nod = Q.front();
        for ( const auto& v : G[nod] )
            if ( !Vis[v] )
            {
                Vis[v] = 1;
                Q.push(v);
            }
        Q.pop();
    }
    for ( int i = 1; i <= N; ++i )
    {
        if ( Vis[i] == 0 )
            return false;
    }
    return true;
}

bool Eulerian()
{
    if ( !Conex() )
        return false;

    for ( int i = 1; i <= N; ++i )
    {
        if ( G[i].size() % 2 == 1 )
            return false;
    }

    return true;
}

void DFS(int v)
{
    int v2;
    while ( true )
    {
        if ( G[v].empty() )
            break;
        v2 = G[v][0];
        S.push(v);
        Delete(v, v2);
        v = v2;
    }
}

void Delete(int x, int y)
{
    for( vector <int> :: iterator it = G[x].begin(); it != G[x].end(); it++ )
    {
        if ( *it == y )
        {
            G[x].erase(it);
            break;
        }
    }
    for( vector <int> :: iterator it = G[y].begin(); it != G[y].end(); it++ )
    {
        if ( *it == x )
        {
            G[y].erase(it);
            break;
        }
    }


}