#include <fstream>
#include <vector>
#include <map>

using namespace std;

ifstream fin("ciclueuler.in");
ofstream fout("ciclueuler.out");

int N, M;
vector<int> V[100005], A[100005], I[100005];
map<pair<int, int>, int> H, HH;
bool used[100005];

void dfs(int nod)
{
    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
    {
        int nod1 = nod;
        int nod2 = *it;
        if (nod1 > nod2)
            swap(nod1, nod2);

        if (!used[*it])
        {
            used[*it] = true;
            A[nod].push_back(*it);
            A[*it].push_back(nod);
            ++HH[make_pair(nod1, nod2)];
            dfs(*it);
        }
        else if (used[*it] && HH[make_pair(nod1, nod2)] < H[make_pair(nod1, nod2)])
        {
            ++HH[make_pair(nod1, nod2)];
            I[nod].push_back(*it);
            I[*it].push_back(nod);
        }
    }
}

void delete_nodI(int now, int nod)
{
    int lg = I[now].size();
    for (int i = 0; i < lg; ++i)
        if (I[now][i] == nod)
        {
            swap(I[now][i], I[now][lg - 1]);
            I[now].pop_back();
            break;
        }
}

void delete_nodA(int now, int nod)
{
    int lg = A[now].size();
    for (int i = 0; i < lg; ++i)
        if (A[now][i] == nod)
        {
            swap(A[now][i], A[now][lg - 1]);
            A[now].pop_back();
            break;
        }
}

void solve(int nod)
{
    fout << nod << ' ';

    while (!I[nod].empty())
    {
        int now = I[nod][0];
        swap(I[nod][0], I[nod][I[nod].size() - 1]);
        I[nod].pop_back();
        delete_nodI(now, nod);

        solve(now);
    }

    while (!A[nod].empty())
    {
        int now = A[nod][0];
        swap(A[nod][0], A[nod][A[nod].size() - 1]);
        A[nod].pop_back();
        delete_nodA(now, nod);

        solve(now);
    }
}

int main()
{
    fin >> N >> M;
    for (int i = 1, nod1, nod2; i <= M; ++i)
    {
        fin >> nod1 >> nod2;

        V[nod1].push_back(nod2);
        V[nod2].push_back(nod1);

        if (nod1 > nod2)
            swap(nod1, nod2);
        ++H[make_pair(nod1, nod2)];
    }

    used[1] = true;
    dfs(1);
    for (int i = 1; i <= N; ++i)
    {
        if (!used[i] || V[i].size() % 2 == 1)
        {
            fout << "-1\n";
            return 0;
        }
    }

    solve(1);

    return 0;
}