#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
    
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,avx,avx2,abm,mmx,tune=native")
 
using namespace __gnu_pbds;
using namespace std;
     
#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define eb emplace_back
 
typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef unsigned long long ull;
typedef vector< int > vi;
typedef vector< vi > vvi;
typedef vector< ll > vll;
typedef vector< vll > vvll;
typedef vector< pii > vpii;
typedef vector< vpii > vvpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;
 
const ll MOD = 998244353;
 
const ull infull = numeric_limits<unsigned long long>::max();
 
void fix(int &x, ll MOD) {
    x = (x % MOD);
    if(x < 0) x += MOD;
    return;
}
 
ll lgput(ll a, ll b, ll MOD) {
    ll ret = 1;
    a %= MOD;
    while(b) {
        if(b&1) ret = ret*a % MOD;
        a = a*a % MOD;
        b >>= 1;
    }
 
    return ret;
}
 
ll inv(ll a, ll MOD) {
    return lgput(a, MOD-2, MOD);
}
 
struct f {
    int a, b;
    f(int _a = 0, int _b = 0) : a(_a) ,b(_b) {}
    ll eval(int x) {
        return 1ll*x*a + b;
    }
};
 
int binarySearch(int x, vi &v) {
    int pos = 0;
    int l = 1, r = sz(v);
    while(l <= r) {
        int m = l + r >> 1;
        if(v[m] <= x) {
            pos = m;
            l = m + 1;
        } else {
            r = m - 1;
        }
    }
 
    return pos;
}
 
using Matrix = vvi;
 
Matrix mult(Matrix a, Matrix b) {
    assert(a[0].size() == b.size());
 
    Matrix ret(a.size(), vector< int >(b[0].size()));
 
    for(int i = 0; i < a.size(); ++i) {
        for(int j = 0; j < b[0].size(); ++j) {
            for(int k = 0; k < a[0].size(); ++k) {
                ret[i][j] += ((1ll*a[i][k]*b[k][j])%MOD);
                if(ret[i][j] >= MOD) ret[i][j] -= MOD;
            }
        }
    }
 
    return ret;
}
 
const double PI = acos(-1);
const double eps = 1e-4;

int main() {
    #ifdef BLAT
        freopen("stdin", "r", stdin);
        freopen("stderr", "w", stderr);
    #else
        FO(ciclueuler);
    #endif

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(12);
    srand(time(NULL));

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

    vector< vector< pair< int, int > > > gr(n + 1);

    vi viz(m + 1);
    for(int i = 0; i < m; ++i) {
        int a, b;
        cin >> a >> b;
        gr[a].eb(b, i);
        gr[b].eb(a, i);
    }

    for(int i = 1; i <= n; ++i) {
        if(gr[i].size()&1) return puts("-1"), 0;
    }


    stack< int > st;
    st.push(1);

    vi sol;
    while(st.size()) {
        int node = st.top();
        st.pop();
        if(gr[node].size()) {
            st.push(node);
            if(!viz[gr[node].back().second]) st.push(gr[node].back().first);
            viz[gr[node].back().second] = true;
            gr[node].pop_back();
        } else sol.eb(node);
    }

    sol.pop_back();

    if(sol.size() != m) return puts("-1"), 0;

    for(auto &x : sol) cout << x << ' ';
    return 0;
}