//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;

const double PI = acos(-1);
const double eps = 1e-6;

inline long long lgput(long long a , long long b , long long mod) {
    long long ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return (ret%mod);
}

inline long long inv(long long x , long long MOD) {
    return lgput(x, MOD - 2, MOD);
}

inline bool exist (double nr){
    return (nr < -eps) || (nr > eps);
}

inline void mod (long long &nr , long long MOD){
    if (nr >= 0 && nr <= 3*MOD){
        while (nr >= MOD){
            nr -= MOD;
        }
        return;
    }
    nr %= MOD;
    if (nr < 0){
        nr += MOD;
    }
}

inline bool gauss (int n , int m , vector < vector < double > > v , vector < double > &ans){

    //transformare matrice (zerouri sub diagonala principala)

    for (int j=1; j<=m; j++){
        int pnt = j;
        while (pnt <= n){
            if (exist(v[pnt][j])){
                swap(v[j] , v[pnt]);
                break;
            }
            pnt++;
        }

        if (pnt > n){
            continue;
        }

        for (int i=j+1; i<=n; i++){
            double cnst = v[i][j] / v[j][j];
            for (int k=j; k<=m+1; k++){
                v[i][k] -= v[j][k] * cnst;
            }
        }
    }

    //aflat raspuns

    for (int i=n; i>=1; i--){
        double sum = 0;
        for (int j=i+1; j<=m; j++){
            if (exist(v[i][j])){
                sum += v[i][j] * ans[j];
            }
        }
        if (i > m && exist(v[i][m+1])){
            return false;
        }
        if (!exist(v[i][i]) && exist(v[i][m+1] - sum)){
            return false;
        }
        if (exist(v[i][i])){
            ans[i] = (v[i][m+1] - sum) / v[i][i];
        }
    }
    return true;
}
inline bool gauss (int n , int m , vector < vector < long long > > v , vector < long long > &ans , long long MOD){

    //transformare matrice (zerouri sub diagonala principala)

    for (int j=1; j<=m; j++){
        int pnt = j;
        while (pnt <= n){
            if (v[pnt][j]){
                swap(v[j] , v[pnt]);
                break;
            }
            pnt++;
        }

        if (pnt > n){
            continue;
        }

        for (int i=j+1; i<=n; i++){
            long long cnst = v[i][j] * inv(v[j][j] , MOD);
            mod(cnst , MOD);
            for (int k=j; k<=m+1; k++){
                v[i][k] -= v[j][k] * cnst;
                mod(v[i][k] , MOD);
            }
        }
    }

    //aflat raspuns

    for (int i=n; i>=1; i--){
        long long sum = 0;
        for (int j=i+1; j<=m; j++){
            if (v[i][j]){
                sum += v[i][j] * ans[j];
                mod(sum , MOD);
            }
        }
        if (i > m && v[i][m+1]){
            return false;
        }
        if (!v[i][i] && v[i][m+1] - sum){
            return false;
        }
        if (v[i][i]){
            ans[i] = (v[i][m+1] - sum) * inv(v[i][i] , MOD);
            mod(ans[i] , MOD);
        }
    }
    return true;
}

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

//#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] < gr[nod].size()){
        if (!edges[gr[nod][poz[nod]]].used){
            dfs(nxt(nod , edges[gr[nod][poz[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<=m; i++){
        int a , b;
        cin>>a>>b;
        edges[i] = {a , b , false};
        gr[a].push_back(i);
        gr[b].push_back(i);
    }

    dfs(1);

    for (int i=1; i<=m; i++){
        if (!edges[i].used){
            cout<<-1;
            return 0;
        }
    }

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

    return 0;
}