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

#define NMax 50005

using namespace std;

vector <int> G[NMax];
stack <int> Stack, Cycle;
int N, Degree[NMax];
bool Viz[NMax];

void Read ()
{
    freopen ("ciclueuler.in", "r", stdin);
    int M;
    scanf ("%d %d", &N, &M);
    for (; M>0; --M)
    {
        int X, Y;
        scanf ("%d %d", &X, &Y);
        G[X].push_back (Y);
        G[Y].push_back (X);
        ++Degree[X];
        ++Degree[Y];
    }
}

void Print ()
{
    freopen ("ciclueuler.out", "w", stdout);
    while (!Cycle.empty ())
    {
        printf ("%d ", Cycle.top ());
        Cycle.pop ();
    }
    printf ("\n");
}

void DFS (int X)
{
    Viz[X]=true;
    for (unsigned v=0; v<G[X].size (); ++v)
    {
        int V=G[X][v];
        if (!Viz[V])
        {
            DFS (V);
        }
    }
}

bool GraphConnectivity ()
{
    DFS (1);
    for (int i=1; i<=N; ++i)
    {
        if (!Viz[i])
        {
            return false;
        }
    }
}

bool EulerianGraph ()
{
    if (!GraphConnectivity ())
    {
        return false;
    }
    for (int i=1; i<=N; ++i)
    {
        if (Degree[i]%2==1)
        {
            return false;
        }
    }
    return true;
}

void Delete (int X, int Y)
{
    G[X].erase (G[X].begin ());
    --Degree[X];
    for (vector <int> :: iterator V=G[Y].begin (); V!=G[Y].end (); ++V)
    {
        if (*V==X)
        {
            G[Y].erase (V);
            --Degree[Y];
            return;
        }
    }
}

void Euler (int X)
{
    while (!G[X].empty ())
    {
        int Y=G[X].front ();
        Delete (X, Y);
        Stack.push (X);
        X=Y;
    }
}

int main()
{
    Read ();
    if (EulerianGraph ())
    {
        int V=1;
        do
        {
            Euler (V);
            V=Stack.top ();
            Stack.pop ();
            Cycle.push (V);
        }
        while (!Stack.empty ());
    }
    else
    {
        Cycle.push (-1);
    }
    Print ();
    return 0;
}