#include <fstream>
#include <vector>
#include <cstring>
#define NMAX 100010
#define MMAX 500010
using namespace std;

struct Edge
{
    int v1, v2;
};

/*int N, M, remainingEdges;
vector<int> G[NMAX], cycle;
vector<int> stack;
bool visited[NMAX];*/

void input(int &N, int &M, int &remainingEdges, Edge *&E, vector<int> *&G)
{
    ifstream in("ciclueuler.in");
    in>>N>>M;
    remainingEdges = M<<1;
    int i, a, b;
    for (i=0; i<M; ++i)
    {
        in>>a>>b;
        E[i].v1 = a;
        E[i].v2 = b;
        G[a].push_back(i);
        G[b].push_back(i);
    }
    in.close();
}

bool testGrades(const int &N, /*const */vector<int> *&G)
{
    for (int i=1; i<=N; ++i)
        if (G[i].size() & 1)
        {
            ofstream out("ciclueuler.out");
            out<<-1;
            return 0;
        }
    return 1;
}

void DFS(vector<int> &stack, vector<int> *&G, vector<int> &cycle, Edge *&E, bool *&visited, int &remainingEdges)
{
    stack.push_back(1);

    while (stack.size() > 0)
    {
        int node = stack[stack.size()-1];
        int i, edge, adjancted;
        for (i=0; i<G[node].size(); ++i)
        {
            visited[node] = 1;
            edge = G[node][i];
            if (E[edge].v1 != node)
                adjancted = E[edge].v1;
            else adjancted = E[edge].v2;
            G[node][i] = G[node][G[node].size()-1];
            G[node].pop_back();

            for (int j=0; j<G[adjancted].size(); ++j)
                if (G[adjancted][j] == edge)
                {
                    G[adjancted][j] = G[adjancted][G[adjancted].size()-1];
                    G[adjancted].pop_back();
                    break;
                }
            --i; remainingEdges -= 2;
            stack.push_back(adjancted);
            node = stack[stack.size()-1];
        }
        cycle.push_back(node);
        stack.pop_back();
    }
}

void output(const int &remainingEdges, const int &N, /*const */bool *&visited, vector<int> &cycle)
{
    ofstream out("ciclueuler.out");
    bool Euler = 1;
    if (remainingEdges > 0)
        Euler = 0;
    for (int i=1; i<=N && Euler; ++i)
        if (visited[i]==0)
            Euler = 0;
    if (!Euler) out<<-1;
    else
    {
        int j, SIZE = cycle.size()-1;
        for (j=0; j<SIZE; ++j)
            out<<cycle[j]<<" ";
    }
    out.close();
}

int main()
{
    int N, M, remainingEdges;
    Edge *E = new Edge[NMAX];
    vector<int> *G=new vector<int>[NMAX], stack, cycle;
    bool *visited = new bool[NMAX];
    memset(visited, 0, sizeof(visited));

    input(N, M, remainingEdges, E, G);
    if (testGrades(N, G) == 0)
        return 0;
    DFS(stack, G, cycle, E, visited, remainingEdges);
    output(remainingEdges, N, visited, cycle);
    return 0;
}