#include <bits/stdc++.h>
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
#define dump(x)                             \
    if (dbg) {                              \
        cerr << #x << " = " << (x) << endl; \
    }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 1e9 + 7;
template <class T>
bool chmin(T& a, const T& b) {
    if (a > b) {
        a = b;
        return 1;
    } else
        return 0;
}
template <class T>
bool chmax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return 1;
    } else
        return 0;
}
void Yes(bool flag = true) {
    if (flag)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
}
void No(bool flag = true) {
    Yes(!flag);
}
void YES(bool flag = true) {
    if (flag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
void NO(bool flag = true) {
    YES(!flag);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val) {
    std::fill((T*)array, (T*)(array + N), val);
}
bool dbg = false;
}  // namespace mydef
using namespace mydef;
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
//#define P pair<int, int>
//#define V vector<int>
//#define S set<int>
#define asn ans

template <typename T>
struct edge {
    int to, id;
    T cost;
    edge(int to) : to(to), id(-1), cost(1) {}
    edge(int to, T cost) : to(to), id(-1), cost(cost) {}
    edge(int to, T cost, int id) : to(to), id(id), cost(cost) {}
    operator int() const { return to; }
    /*
        edge& operator=(const int& x) {
            to = x;
            return *this;
        }
        */
};
template <typename T>
class Graph : public vector<vector<edge<T>>> {
    //--------Basic--------
private:
    using Edge = edge<T>;
    int M;  //M:辺の数
    bool undirected = false;
    bool directed = false;
    bool unweighted = false;
    bool weighted = false;
    //
public:
    Graph() = default;
    //unweighted
    void add_edge_undirected(int u, int v, int id = -1) {
        assert(!directed);
        assert(!weighted);
        undirected = true;
        (*this)[u].emplace_back(Edge{v, 1, id});
        (*this)[v].emplace_back(Edge{u, 1, id});
    }
    void build_undirected(int m) {
        assert(!(*this).empty());
        assert(!directed);
        undirected = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            cin >> u >> v;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, 1, i});
            (*this)[v].emplace_back(Edge{u, 1, i});
        }
    }
    void build_undirected(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    void add_edge_directed(int u, int v, int id = -1) {
        assert(!undirected);
        directed = true;
        (*this)[u].emplace_back(Edge{v, 1, id});
    }
    void build_directed(int m) {
        assert(!(*this).empty());
        assert(!undirected);
        directed = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            cin >> u >> v;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, 1, i});
        }
    }
    void build_directed(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    //weighed
    void add_edge_undirected_weighed(int u, int v, T cost, int id = -1) {
        assert(!directed);
        undirected = true;
        (*this)[u].emplace_back(Edge{v, cost, id});
        (*this)[v].emplace_back(Edge{u, cost, id});
    }
    void build_undirected_weighted(int m) {
        assert(!(*this).empty());
        assert(!directed);
        undirected = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            T cost;
            cin >> u >> v >> cost;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, cost, i});
            (*this)[v].emplace_back(Edge{u, cost, i});
        }
    }
    void build_undirected_weighted(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    void add_edge_directed_weighted(int u, int v, T cost, int id = -1) {
        assert(!undirected);
        directed = true;
        (*this)[u].emplace_back(Edge{v, cost, id});
    }
    void build_directed_weighted(int m) {
        assert(!(*this).empty());
        assert(!undirected);
        directed = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            T cost;
            cin >> u >> v >> cost;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, cost, i});
        }
    }
    void build_directed_weighted(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    //print state
    void state() {
        cerr << endl
             << "Print State" << endl
             << "Edge :" << endl
             << "    Directed   : " << (directed ? "Yes" : "No") << endl
             << "    Undirected : " << (undirected ? "Yes" : "No") << endl
             << "Usable Functions" << endl
             << "    StronglyConnectedComponent : " << (StronglyConnectedComponent_ready ? "Yes" : "No") << endl;
    }
    //
    //
    //
    //--------StronglyConnectedComponent--------
    //Unverified
public:
    vector<vector<int>> SCC_R, SCC_T;
    //
private:
    bool StronglyConnectedComponent_ready = false;
    vector<int> SCC_cmp, SCC_ord;
    vector<bool> SCC_used;
    //
public:
    int SCC_build() {
        cerr << "Please Verify" << endl;
        assert(!undirected);
        assert(directed);
        int N = (*this).size();
        SCC_R.resize(N);
        for (int i = 0; i < N; i++) {
            for (int& x : (*this)[i]) {
                SCC_R[x].emplace_back(i);
            }
        }
        SCC_cmp.resize(N);
        fill(SCC_cmp.begin(), SCC_cmp.end(), -1);
        SCC_used.resize(N);
        fill(SCC_used.begin(), SCC_used.end(), false);
        StronglyConnectedComponent_ready = true;
        return build_StronglyConnectedComponent_init();
    }
    int SCC(int k) {
        assert(StronglyConnectedComponent_ready);
        return SCC_cmp[k];
    }
    //
private:
    void dfs(int now) {
        if (SCC_used[now])
            return;
        SCC_used[now] = true;
        for (auto nxt : (*this)[now])
            dfs(nxt);
        SCC_ord.emplace_back(now);
    }
    void rdfs(int now, int count) {
        if (SCC_cmp[now] != -1)
            return;
        SCC_cmp[now] = count;
        for (auto to : SCC_R[now])
            rdfs(to, count);
    }
    int build_StronglyConnectedComponent_init() {
        int n = (int)(*this).size();
        for (int i = 0; i < n; i++)
            dfs(i);
        reverse(SCC_ord.begin(), SCC_ord.end());
        int group = 0;
        for (auto& i : SCC_ord) {
            if (SCC_cmp[i] == -1) {
                rdfs(i, group);
                group++;
            }
        }
        SCC_T.resize(group);
        for (int i = 0; i < n; i++) {
            for (auto& to : (*this)[i]) {
                int s = SCC_cmp[i], t = SCC_cmp[to];
                if (s != t)
                    SCC_T[s].emplace_back(t);
            }
        }
        return group;
    }
    //
    //
    //
    //--------TopologicalSort--------
    //未実装
};
//グローバルでの使用のみ想定


int N, M;
Graph<int> G;

vi ans;
int used[202020];

void f(int x) {
    if (!used[x])
        ans.emplace_back(x);
    used[x] = 1;
    for (auto& nxt : G[x]) {
        if (!used[nxt]) {
            f(nxt);
            return;
        }
    }
}

void solve() {
    G.build_undirected(N, M);
    f(0);
    reverse(all(ans));
    f(0);
    cout << ans.size() << endl;
    for (auto& x : ans)
        cout << x + 1 << " ";
    cout << endl;
    G.state();
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    cin >> N >> M;

    solve();
    return 0;
}


Measured memory_bytes: 16556