//ALEX ENACHE

#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <unordered_map>
#include <time.h>
#include <iomanip>
#include <deque>
#include <math.h>
#include <cmath>
#include <assert.h>
#include <stack>
#include <bitset>
#include <random>
#include <chrono>

using namespace std;

//-------------------------------------------------------------------

//#include <iostream>
#include <fstream>
ifstream cin ("ciclueuler.in");ofstream cout ("ciclueuler.out");

vector < int > gr[100100];
int poz[100100];

struct edge{
    int st , dr;
    bool used;
};

edge edges[500100];

int nxt(int nod , edge &edg){
    edg.used = true;
    if (edg.st == nod){
        return edg.dr;
    }
    return edg.st;
}

vector < int > ans;

void dfs(int nod){
    while (poz[nod] + 1 < (int)gr[nod].size()){
        poz[nod]++;
        if (!edges[gr[nod][poz[nod]]].used){
            dfs(nxt(nod , edges[gr[nod][poz[nod]]]));
        }
    }
    ans.push_back(nod);
}

int main() {

    //freopen("input", "r", stdin);freopen("output", "w", stdout);

    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout << setprecision(10) << fixed;
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    srand(time(nullptr));

    int n , m;
    cin>>n>>m;

    for (int i=1; i<=n; i++){
        poz[i] = -1;
    }

    for (int i=1; i<=m; i++){
        int a , b;
        cin>>a>>b;
        edges[i] = {a , b , false};
        gr[a].push_back(i);
        gr[b].push_back(i);
    }

    for (int i=1; i<=n; i++){
        if (gr[i].size() % 2){
            cout<<-1;
            return 0;
        }
    }

    dfs(1);

    ans.pop_back();

    if (ans.size() != m){
        cout<<-1;
        return 0;
    }

    for (auto &x : ans){
        cout<<x<<" ";
    }

    return 0;
}