#include <fstream>
#include <list>
#include <stack>
#define in "ciclueuler.in"
#define out "ciclueuler.out"
#define Max_Size 100009

std :: ifstream f(in);
std :: ofstream g(out);

int N, M, nr_nod_viz;
int IO[Max_Size], X[Max_Size], Y[Max_Size], Sol[Max_Size];
bool Viz[Max_Size];

std :: list < int > V[Max_Size];
std :: stack < int > Stack;

inline void Read_Data()
{
    f >> N >> M;

    for(int i = 1; i <= M; ++i)
    {
        f >> X[i] >> Y[i];

        V[X[i]].push_back(Y[i]);
        V[Y[i]].push_back(X[i]);
        IO[X[i]] ++, IO[Y[i]] ++;
    }
}

void DFS(int nod)
{
    std :: list < int > :: iterator it;

    Viz[nod] = 1;

    for(it = V[nod].begin(); it != V[nod].end(); ++it)
        if(!Viz[*it])
            DFS(*it);

    ++nr_nod_viz;
}

inline bool  It_Is_Euler()
{
    DFS(1);

    if(nr_nod_viz != N) return 0;

    for(int i = 1; i <= N; ++i) if(IO[i] % 2)   return 0;

    return 1;
}

inline void Euler(int nod)
{
    int nod1;
    std :: list < int > :: iterator it;

    while(!V[nod].empty())
    {
        nod1 = V[nod].front();
        V[nod].pop_front();

        Stack.push(nod);

        for(it = V[nod1].begin(); it != V[nod1].end(); ++it)
            if(*it == nod)
            {
                V[nod1].erase(it);
                break;
            }

        nod = nod1;
    }
}

inline void Solve()
{
    Stack.push(1);
    int K = 0;

    while(!Stack.empty())
    {
        int nod = Stack.top();
        Stack.pop();

        Euler(nod);
        ++K;

        if(K != M + 1)  g << nod << ' ';
    }
}

int main()
{
    Read_Data();

    if(It_Is_Euler())
        Solve();
    else
        g << "-1\n";

    g.close();
    return 0;
}