#include <fstream>
#include <vector>

using namespace std;

const int NMAX = 100000;

int n, m;

vector<pair<int, int>> graf[1 + NMAX];
vector<int> stiva;
vector<int> sol;

bool vizitat[1 + NMAX];

void dfs(int nod)
{
  vizitat[nod] = true;

  for (auto& vecin : graf[nod])
    if (!vizitat[vecin.first])
      dfs(vecin.first);
}

bool esteEulerian()
{
  dfs(1);

  for (int i = 1; i <= n; i++)
    if (!vizitat[i] || graf[i].size() % 2 == 1)
      return false;

  return true;
}

void sterge(int a)
{
  int b = graf[a].back().first;
  int indexB = graf[a].back().second;

  graf[a].pop_back();

  if (indexB < graf[b].size() - 1)
  {
    swap(graf[b][indexB], graf[b].back());
    int c = graf[b][indexB].first;
    int indexC = graf[b][indexB].second;
    graf[c][indexC].second = indexB;
  }

  graf[b].pop_back();
}

void ciclu(int nod)
{
  stiva.push_back(nod);

  if (!graf[nod].empty())
  {
    int vecin = graf[nod].back().first;
    sterge(nod);
    ciclu(vecin);
  }
}

void cicluEulerian()
{
  stiva.push_back(1);

  while (!stiva.empty())
  {
    int nod = stiva.back();
    stiva.pop_back();

    if (!graf[nod].empty())
      ciclu(nod);
    else
      sol.push_back(nod);
  }
}

int main()
{
  ifstream in("ciclueuler.in");
  ofstream out("ciclueuler.out");

  in >> n >> m;

  for (int j = 1; j <= m; j++)
  {
    int u, v;
    in >> u >> v;

    if (u == v)
    {
      graf[u].emplace_back(u, graf[u].size() + 1);
      graf[u].emplace_back(u, graf[u].size() - 1);
    }
    else
    {
      graf[u].emplace_back(v, graf[v].size());
      graf[v].emplace_back(u, graf[u].size() - 1);
    }
  }

  if (!esteEulerian())
  {
    out << -1 << '\n';
    return 0;
  }

  cicluEulerian();

  for (int i = 0; i < sol.size() - 1; i++)
    out << sol[i] << ' ';
  out << '\n';

  return 0;
}