#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, M;
    std::cin >> N >> M;
    
    std::vector<std::vector<int>> adj(N);
    for (int i = 0; i < M; i++) {
        int u, v;
        std::cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    
    std::vector<bool> vis(N);
    std::vector<int> dep(N), p(N);
    p[0] = -1;
    auto dfs = [&](auto &self, int x) -> void {
        vis[x] = true;
        for (auto y : adj[x]) {
            if (!vis[y]) {
                dep[y] = dep[x] + 1;
                p[y] = x;
                self(self, y);
            }
        }
    };
    dfs(dfs, 0);
    
    int rt = std::max_element(dep.begin(), dep.end()) - dep.begin();
    std::fill(vis.begin(), vis.end(), false);
    std::fill(p.begin(), p.end(), -1);
    dep[rt] = 0;
    dfs(dfs, rt);
    
    if (*std::max_element(dep.begin(), dep.end()) == N - 1) {
        std::cout << 2 * N << "\n";
        for (int i = 0; i < 2 * N; i++) {
            for (int x = 0; x < N; x++) {
                int c;
                if (dep[x] % 2 == i % 2) {
                    c = x;
                } else if (x != rt) {
                    c = p[x];
                } else {
                    c = rt;
                }
                std::cout << c << " \n"[x == N - 1];
            }
        }
        return 0;
    }
    
    int u = rt;
    std::vector<int> deg(N);
    for (int i = 0; i < N; i++) {
        if (p[i] != -1) {
            deg[p[i]]++;
        }
    }
    for (int i = 0; i < N; i++) {
        if (dep[i] > dep[u] && deg[i] > 1) {
            u = i;
        }
    }
    std::vector<bool> ef(N);
    assert(u != rt);
    int f = p[u];
    for (auto y : adj[f]) {
        ef[y] = true;
    }
    
    int v = -1;
    for (int i = 0; i < N; i++) {
        if (p[i] == u) {
            if (v == -1 || !ef[i]) {
                v = i;
            }
        }
    }
    assert(v != -1);
    
    std::vector<int> path;
    for (int i = v; ; ) {
        int j = -1;
        for (auto x : adj[i]) {
            if (p[x] == i) {
                j = x;
                break;
            }
        }
        if (j == -1) {
            break;
        }
        i = j;
        path.push_back(i);
    }
    
    std::fill(vis.begin(), vis.end(), false);
    dep[v] = 0;
    for (auto x : path) {
        vis[x] = true;
    }
    std::swap(adj[v][0], *std::find(adj[v].begin(), adj[v].end(), u));
    if (!ef[v]) {
        std::swap(adj[u][0], *std::find(adj[u].begin(), adj[u].end(), f));
    } else {
        std::partition(adj[u].begin(), adj[u].end(),
            [&](int i) {
                return p[i] == u;
            });
    }
    std::fill(p.begin(), p.end(), -1);
    dfs(dfs, v);
    
    std::vector<bool> onpath(N);
    for (int i = 0; i < path.size(); i++) {
        dep[path[i]] = i + 1;
        onpath[path[i]] = true;
        p[path[i]] = i ? path[i - 1] : v;
    }
    
    std::cout << 6 * N << "\n";
    for (int i = 0; i < 6 * N; i++) {
        for (int x = 0; x < N; x++) {
            int c;
            if (i % 3 == 0) {
                if (dep[x] % 2 == 1 && (path.empty() || x != path[0])) {
                    c = p[x];
                } else {
                    c = x;
                }
            } else if (i % 3 == 1) {
                if (x == v) {
                    c = u;
                } else if (dep[x] % 2 == 0) {
                    c = p[x];
                } else {
                    c = x;
                }
            } else {
                if (!path.empty() && x == path[0]) {
                    c = v;
                } else {
                    c = x;
                }
            }
            std::cout << c << " \n"[x == N - 1];
        }
    }
    
    return 0;
}