#pragma GCC optimize("Ofast")
#include <stdio.h>
#include <unistd.h>

#define NMAX 100000
#define MMAX 500000
#define CHUNK (1 << 24)

static struct edge {
    int node;
    int prev, next;
    int compl;
} edges[2*MMAX+1];

static int adj[NMAX+1], sol[MMAX+1], nsol;
static int deg[NMAX+1];

static char *pbuf, buf[CHUNK], obuf[CHUNK >> 2];
static ssize_t oblen = (CHUNK >> 2) - 1, blen;

static inline int read_int(void)
{
    int x = 0;

    while ('0' <= *pbuf && *pbuf <= '9') {
        x = x * 10 + (*pbuf - '0');
        pbuf++;
    }

    pbuf++;
    return x;
}

static inline void write_int(int x)
{

    if (x == -1) {
        obuf[oblen--] = ' ';
        obuf[oblen--] = '1';
        obuf[oblen--] = '-';
        return;
    }

    obuf[oblen--] = ' ';

    do {
        obuf[oblen--] = '0' + x % 10;
        x /= 10;
    } while (x);
}

static inline void ciclueuler(int v)
{
    int compl, node;

    while (adj[v] != 0) {
        compl = edges[adj[v]].compl;
        node = edges[adj[v]].node;

        adj[v] = edges[adj[v]].next;
        edges[adj[v]].prev = 0;

        if (adj[node] == compl) {
            adj[node] = edges[adj[node]].next;
            edges[adj[node]].prev = 0;
        } else {
            edges[edges[compl].prev].next = edges[compl].next;
            edges[edges[compl].next].prev = edges[compl].prev;
        }

        ciclueuler(node);
    }

    sol[nsol++] = v;
}

int main()
{
    int n, m, u, v, i;

    freopen("ciclueuler.in", "r", stdin);
    freopen("ciclueuler.out", "w", stdout);

    blen = read(STDIN_FILENO, buf, CHUNK);
    pbuf = buf;

    n = read_int();
    m = read_int();

    for (i = 1; i <= m; i++) {
        u = read_int();
        v = read_int();

        edges[2*i].node = v;
        edges[2*i].next = adj[u];
        edges[2*i].prev = 0;
        edges[2*i].compl = 2*i+1;
        edges[adj[u]].prev = 2*i;
        adj[u] = 2*i;

        deg[u]++;
        deg[v]++;

        if (u != v) {
            edges[2*i+1].node = u;
            edges[2*i+1].next = adj[v];
            edges[2*i+1].prev = 0;
            edges[2*i+1].compl = 2*i;
            edges[adj[v]].prev = 2*i+1;
            adj[v] = 2*i+1;
        }
    }

    for (v = 1; v <= n; v++) {
        if (deg[v] % 2) {
            write_int(-1);
            write(STDOUT_FILENO, obuf + oblen + 1, (CHUNK >> 2) - oblen - 2);
            return 0;
        }
    }

    ciclueuler(1);

    for (i = nsol - 2; i >= 0; i--) {
        write_int(sol[i]);
    }
    write(STDOUT_FILENO, obuf + oblen + 1, (CHUNK >> 2) - oblen - 2);

    return 0;
}