#include <bits/stdc++.h>

using namespace std;

struct Edge {
  size_t to;
  size_t id;
};

vector<size_t> euler(size_t start, vector<vector<Edge>>& g, vector<char>& used,
                     size_t M) {
  vector<size_t> st, cycle;
  st.push_back(start);

  while (!st.empty()) {
    size_t u = st.back();
    while (!g[u].empty() && used[g[u].back().id]) g[u].pop_back();

    if (!g[u].empty()) {
      auto [v, id] = g[u].back();
      g[u].pop_back();
      used[id] = 1;
      st.push_back(v);
    } else {
      cycle.push_back(u);
      st.pop_back();
    }
  }
  reverse(cycle.begin(), cycle.end());
  return cycle;
}

int main() {
#ifndef LOCAL
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  freopen("ciclueuler.in", "r", stdin);
  freopen("ciclueuler.out", "w", stdout);
#endif
  size_t N, M;
  if (!(cin >> N >> M)) return 0;

  vector<vector<Edge>> g(N);
  vector<size_t> deg(N);
  for (size_t i = 0; i < M; ++i) {
    size_t u, v;
    cin >> u >> v;
    --u;
    --v;
    g[u].push_back({v, i});
    g[v].push_back({u, i});
    ++deg[u];
    ++deg[v];
  }

  // 1. Check all degrees even
  for (size_t d : deg)
    if (d % 2) {
      cout << "-1\n";
      return 0;
    }

  // 2. Check connectivity on non-isolated vertices
  size_t start = 0;
  while (start < N && deg[start] == 0) ++start;
  if (start == N) {
    cout << "-1\n";
    return 0;
  }

  vector<char> vis(N);
  stack<size_t> s;
  s.push(start);
  while (!s.empty()) {
    size_t u = s.top();
    s.pop();
    if (vis[u]) continue;
    vis[u] = 1;
    for (auto& e : g[u])
      if (!vis[e.to]) s.push(e.to);
  }
  for (size_t i = 0; i < N; ++i)
    if (deg[i] && !vis[i]) {
      cout << "-1\n";
      return 0;
    }

  // 3. Build Eulerian cycle
  vector<char> used(M);
  auto cycle = euler(start, g, used, M);

  // 4. Validate
  if (cycle.size() != M + 1) {
    cout << "-1\n";
    return 0;
  }

  // 5. Output first M vertices (1-indexed)
  for (size_t i = 0; i < M; ++i) {
    if (i) cout << ' ';
    cout << cycle[i] + 1;
  }
  cout << '\n';
}