#include <bits/stdc++.h>

using namespace std;

ifstream f("ciclueuler.in");
ofstream g("ciclueuler.out");

const int nmax=100005;
vector < vector <int> > gr(nmax);
vector <int> euler;
int viz[nmax],x,y,n,m;

vector < unordered_map<int, int> > used(nmax);


void dfs(int nod)
{
    viz[nod]=true;
    for (int vec:gr[nod] )
        if ( !viz[vec] )
            dfs(vec);
}

bool is_eulerian(int n)
{
    for (int i=1; i<=n; i++ )
        if ( gr[i].size()%2!=0 )
            return false;

    int start=1;
    while ( gr[start].empty() && start<=n )
        start++;

    fill(viz+1,viz+n+1,0);
    dfs(start);

    for (int i=1; i<=n; i++ )
        if ( !gr[i].empty() && !viz[i] )
            return false;

    return true;
}

void euler_cycle(int start)
{
    stack <int> st;
    st.push(start);

    while ( !st.empty() )
    {
        int nod=st.top();

        while ( !gr[nod].empty() && used[nod][gr[nod].back()] )
            gr[nod].pop_back();

        if ( !gr[nod].empty() )
        {
            int next=gr[nod].back();
            gr[nod].pop_back();
            used[nod][next]++;
            used[next][nod]++;

            st.push(next);
        }
        else
        {
            euler.push_back(nod);
            st.pop();
        }
    }
}

int main()
{
    f >> n >> m;
    for (int i=1; i<=m; i++ )
    {
        f >> x >> y;
        gr[x].push_back(y);
        gr[y].push_back(x);
    }

    if ( is_eulerian(n) )
    {
        int start=1;
        while ( gr[start].empty() && start<=n )
            start++;

        euler_cycle(start);

        for (int i=0; i<euler.size(); i++ )
            g << euler[i] << " ";
    }
    else g << -1;
    return 0;
}