#include <iostream>
#include <fstream>
#include <vector>
#include <stack>

using namespace std;

const int Nmax = 100005;

int N, M;
vector <int> G[Nmax];
stack <int> Stack;
int degree[Nmax];
int vis[Nmax];

void DFS( int nod )
{
    vis[nod] = 1;

    for ( unsigned i = 0; i < G[nod].size(); ++i )
            if ( !vis[ G[nod][i] ] )
                    DFS( G[nod][i] );
}

int IsEulerian()
{
    int g2 = 0;

    for ( int i = 1; i <= N; ++i )
            g2 += ( degree[i] % 2 );

    DFS( 1 );

    for ( int i = 1; i <= N; ++i )
            if ( vis[i] == 0 )
                g2 = 1;

    return ( g2 == 0 );
}

void Euler( int nod )
{
    while ( G[nod].size() )
    {
        int vecin = G[nod].back();
        G[nod].pop_back();

        Stack.push( nod );

        for ( vector <int> ::iterator it = G[vecin].begin(); it != G[vecin].end(); ++it )
        {
            if ( *it == nod )
            {
                G[vecin].erase( it );
                break;
            }
        }

        nod = vecin;
    }
}

void Eulerian_Cycle()
{
    ofstream g("euler.out");

    int nr = 0;

    Stack.push( 1 );

    do
    {
        int nod = Stack.top();
        Stack.pop();
        Euler( nod );
        nr++;

        if ( nr != M + 1 )
                g << nod << " ";

    } while ( !Stack.empty() );
}

int main()
{
    ifstream f("euler.in");

    f >> N >> M;

    for ( int i = 1, a, b; i <= M; ++i )
    {
        f >> a >> b;

        degree[a]++;
        degree[b]++;

        G[a].push_back( b );
        G[b].push_back( a );
    }

    if ( IsEulerian() )
    {
        Eulerian_Cycle();
    }
    else
    {
        ofstream g("euler.out");

        g << "-1\n";
    }

    return 0;
}