#include <stdio.h>
#include <iostream>
#include <vector>
#include <unordered_set>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <string.h>
#include <string>
#include <deque>
#include <ctype.h>
#include <limits.h>
#include <map>
#include <set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <functional>
#include <limits.h>
#include <random>

using namespace std;
typedef long long ll;

void solve();
mt19937 rng(time(0));
ll qpow(ll x, ll p, ll MOD) {
    ll res = 1, v = x;
    while (p) {
        if(p & 1) {
            res *= v;
            res %= MOD;
        }
        v *= v;
        v %= MOD;
        p >>= 1;
    }
    return res;
}
ll inv(ll x, ll MOD) {
    return qpow(x, MOD - 2, MOD);
}
void init() {
#ifdef _LOCAL_ 
    if(!freopen("case.txt", "r", stdin)) {
        perror("open file failed!:");
        exit(1);
    }
    if(!freopen("main.ans", "w", stdout)) {
        perror("open file failed!:");
        exit(1);
    }
#endif
}
#ifdef _LOCAL_
void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#   define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#   define dbg(...)
#endif
ll read() {
    int ch = getchar();
    if(ch == EOF) {
        return INT_MIN;
    }
    while(!isdigit(ch) && ch != '-') {
        ch = getchar();
        if(ch == EOF) {
            return INT_MIN;
        }
    }
    ll res = 0, sign = 1;
    if(ch == '-') {
        ch = getchar();
        sign = -1;
    }
    while(isdigit(ch)) {
        res = res * 10 + ch - '0';
        ch = getchar();
    }
    return res * sign;
}
int nextchar() {
    int ch = getchar();
    while(ch == ' ' || ch == '\n' || ch == '\r') {
        ch = getchar();
    }
    return ch;
}
int main() {
    init();
    solve();
    return 0;
}
/** 写之前 : 
 *  1. MAXN 是否定义正确？
 */
/*********************code start here*********************/
const int MAXN = 3005;
vector<pair<int,int>> G[MAXN];
vector<int> deg(MAXN, 0), del(MAXN, 0), vis(MAXN, 0);
vector<int> path;

void dfs(int node) {
    for(auto [ne, e] : G[node]) {
        if(!del[e] && !vis[e]) {
            vis[e] = 1;
            dfs(ne);
        }
    }
    path.push_back(node);
}

bool check(int node, int n, int m) {
    for(int i = 0; i < m; ++i) {
        if(!del[i] && !vis[i]) {
            return false;
        }
    }
    for(int i = 1; i <= n; ++i) {
        if(i != node && i != path[0] && (deg[i] & 1)) {
            return false;
        }
    }
    if((deg[node] & 1) != (deg[path[0]] & 1)) {
        return false;
    }
    return true;
}

bool eular(int node, int n, int m) {
    path.clear();
    fill(vis.begin(), vis.end(), 0);
    dfs(node);
    for(auto [ne, e] : G[node]) {
        if(del[e]) {
            deg[node]--;
            deg[ne]--;
        }
    }
    bool ok = check(node, n, m);
    for(auto [ne, e] : G[node]) {
        if(del[e]) {
            deg[node]++;
            deg[ne]++;
        }
    }
    return ok;
}

void solve() {
    int n = read(), m = read();
    for(int i = 0; i < m; ++i) {
        int u = read(), v = read();
        G[u].push_back({v, i});
        G[v].push_back({u, i});
        deg[u]++;
        deg[v]++;
    }

    bool ok = false;

    for(int i = 1; i <= n; ++i) {
        // no del
        if((ok = eular(i, n, m))) {
            break;
        }

        for(auto [ne, e] : G[i]) {
            del[e] = deg[ne] & 1;
        }

        if((ok = eular(i, n, m))) {
            path.push_back(-1);
            for(auto [ne, e] : G[i]) {
                if(del[e]) {
                    path.push_back(ne);
                    path.push_back(i);
                }
            }
            break;
        }

        for(auto [ne, e] : G[i]) {
            del[e] ^= 1;
            if((ok = eular(i, n, m))) {
                path.push_back(-1);
                for(auto [ne, e] : G[i]) {
                    if(del[e]) {
                        path.push_back(ne);
                        path.push_back(i);
                    }
                }
                break;
            }
            del[e] ^= 1;
        }
        if(ok) {
            break;
        }

        for(auto [ne, e] : G[i]) {
            del[e] = 0;
        }
    }

    if(ok) {
        printf("%d\n", path.size());
        for(int v : path) {
            printf("%d ", v);
        }
        printf("\n");
    } else {
        printf("0\n");
    }
}

/** 提交前检查 : 
 *  1. 答案和中间结果是否应该是 ll?
 *  2. 是否还有没有读入的数据？
 *  3. 是否有 n = 1 的情况？
 */