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

using namespace std;

ifstream fin("ciclueuler.in");
ofstream fout("ciclueuler.out");

const int MAXN = 100005;
const int MAXM = 500005;

struct Edge {
    int to;
    int id;
};

vector<Edge> adj[MAXN];
int degree[MAXN];
bool visited_edge[MAXM];
int ciclu[MAXN];
int nrNoduri = 0;

void Euler(int v)
{
    while(!adj[v].empty())
    {
        Edge w = adj[v].back();
        adj[v].pop_back();

        if (visited_edge[w.id]) continue;
        visited_edge[w.id] = true;

        Euler(w.to);
    }
    ciclu[nrNoduri++] = v;
}

int main() {
    int N, M;
    fin >> N >> M;

    for (int i = 1; i <= M; ++i) {
        int u, v;
        fin >> u >> v;
        adj[u].push_back({v, i});
        adj[v].push_back({u, i});
        degree[u]++;
        degree[v]++;
    }
    
    int start_node = -1;
    for(int i = 1; i <= M; i++)
    {
        if(degree[i] % 2 == 1)
        {
            fout<<"-1";
        }
        else
        {
            if(start_node == -1 && degree[i] > 0)
            {
                start_node = i;
            }
        }
    }

    if(start_node == -1)
    {
        fout<<"-1";
    }

    Euler(start_node);

    int k = 0;
    while(k < nrNoduri - 1)
    {
        fout<<ciclu[k]<<" ";
        k++;
    }

    /*stack<int> st;
    st.push(start_node);

    while(!st.empty())
    {
        int u = st.top();

        if(!adj[u].empty() && visited_edge[adj[u].back().id])
        {
            adj[u].pop_back();
        }

        if(!adj[u].empty())
        {
            Edge e = adj[u].back();
            adj[u].pop_back();

            visited_edge[e.id] = 1;
            st.push(e.to);
        }
        else
        {

        }


    }*/


}