#include <array>
#include <bitset>
#include <cassert>
#include <cstdint>
#include <forward_list>
#include <fstream>
#include <utility>
#include <vector>


constexpr size_t MAX_NODES = 100000;
constexpr size_t MAX_EDGES = 500000;



std::bitset<MAX_EDGES> usedEdge;


std::array<std::vector<std::pair<size_t, size_t>>, MAX_NODES> edges;


bool edgesLeft (size_t node) {
    while (!edges[node].empty() && usedEdge[edges[node].back().second])
        edges[node].pop_back();

    return !edges[node].empty();
}

constexpr size_t NO_MORE_EDGES = -1;
size_t getNextNode (size_t node) {
    if (edgesLeft(node)) {
        const auto [toNode, edgeIndex] = edges[node].back();
        edges[node].pop_back();

        usedEdge[edgeIndex] = true;
        return toNode;
    } else {
        return NO_MORE_EDGES;
    }
}

std::vector<size_t> result;

void findCycle (const size_t start) {
    size_t node = start;
    while ((node = getNextNode(start)) != NO_MORE_EDGES)
        findCycle(node);
    result.emplace_back(start);
}


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

    size_t nodeCount, edgeCount;
    in >> nodeCount >> edgeCount;

    for (size_t i = 0; i != edgeCount; ++ i) {
        size_t u, v;
        in >> u >> v;
        -- u, -- v;

        edges[u].emplace_back(v, i);
        edges[v].emplace_back(u, i);
    }

    for (size_t i = 0; i != edgeCount; ++ i) {
        if (edges[i].size() % 2 == 1) {
            out << "-1\n";
            return 0;
        }
    }

    findCycle(0);
    result.pop_back();

    for (const auto &node: result)
        out << node + 1 << ' ';
}