#include <bits/stdc++.h>

#define currentNode destination[it] + origin[it] - node

using namespace std;

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

const int N = 1e5+10;
const int M = 5*N;

int totalNodes, totalEdges, mask;

int destination[M], origin[M], arboreEdges[M];

vector <int> edges[N];

bitset <N> visited;

void deepFirstSearch(int node = 1){
    visited[node] = true;
    mask--;
    for (auto it : edges[node]){
        if ( !visited[currentNode]){
            arboreEdges[it] = 1;
            deepFirstSearch(currentNode);
        }
    }
}

int main(){
    fin >> totalNodes >> totalEdges;
    for (int index = 1; index <= totalEdges; index++){
        fin >> origin[index] >> destination[index];
        edges[origin[index]].push_back(index);
        edges[destination[index]].push_back(index);
    }

    for (int index = 1; index <= totalEdges; index++)
        if (edges[index].size()%2){
            fout << -1 << "\n";
            return 0;
        }

    mask = totalNodes;
    deepFirstSearch();
    if (mask){
        fout << -1 << "\n";
        return 0;
    }

    for (int index = 1; index <= totalNodes; index++){
        for (int left = 0, right = edges[index].size()-1 ; left < right; ){
            for (; arboreEdges[edges[index][left]] == 1 and left < right;)
                left++;
            for (; arboreEdges[edges[index][right]] == 0 and left < right;)
                right--;
            if (left < right){
                swap(edges[index][left], edges[index][right]);
                left++;
                right--;
            }
        }
    }

    mask = 2*totalEdges-1;
    int node = 1;

    for (int index; true;){
        for (; edges[node].size() and arboreEdges[edges[node].back()] == 2;){
            edges[node].pop_back();
            mask--;
        }

        if (edges[node].size() == 0)
            break;
        fout << node << " ";
        index = edges[node].back();
        arboreEdges[index] = 2;
        edges[node].pop_back();
        mask--;
        node = origin[index] + destination[index] - node;
    }
    return 0;
}