#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cinttypes>
#include <cassert>
#include <cinttypes>

using namespace std;

#if defined(_MSC_VER)
#pragma warning(disable: 4996)  // VSでscanfを使う．
#endif

// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  types                                                                                                                        /
// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef unsigned int uint;
typedef int64_t ll;
typedef uint64_t ull;

typedef pair<ll, ll> P;
inline P operator+(const P& p1, const P& p2) { return P(p1.first + p2.first, p1.second + p2.second); }
inline P operator-(const P& p1, const P& p2) { return P(p1.first - p2.first, p1.second - p2.second); }
inline P operator*(const P& p1, const P& p2) { return P(p1.first * p2.first, p1.second * p2.second); }
inline P operator/(const P& p1, const P& p2) { return P(p1.first / p2.first, p1.second / p2.second); }

// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  IO                                                                                                                        /
// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Print(const int& x)    { printf("%d\n", x);          }
void Print(const uint& x)   { printf("%u\n", x);          }
void Print(const ll& x)     { printf("%" PRId64 "\n", x); }
void Print(const ull& x)    { printf("%" PRIu64 "\n", x); }
void Print(const float& x)  { printf("%.15f\n", x);       }
void Print(const double& x) { printf("%.15f\n", x);       }
void Print(const string& x) { printf("%s\n", x.c_str());  }
void Print(const char& x)   { printf("%c\n", x);          }
template<class ...T> void Print(const int& x, const T& ...args)    { printf("%d ", x);          Print(args...); }
template<class ...T> void Print(const uint& x, const T& ...args)   { printf("%u ", x);          Print(args...); }
template<class ...T> void Print(const ll& x, const T& ...args)     { printf("%" PRId64 " ", x); Print(args...); }
template<class ...T> void Print(const ull& x, const T& ...args)    { printf("%" PRIu64 " ", x); Print(args...); }
template<class ...T> void Print(const float& x, const T& ...args)  { printf("%.15f ", x);       Print(args...); }
template<class ...T> void Print(const double& x, const T& ...args) { printf("%.15f ", x);       Print(args...); }
template<class ...T> void Print(const string& x, const T& ...args) { printf("%s ", x.c_str());  Print(args...); }
template<class ...T> void Print(const char& x, const T& ...args)   { printf("%c ", x);          Print(args...); }

void Read(int& x)    { scanf("%d", &x);       }
void Read(uint& x)   { scanf("%u", &x);       }
void Read(ll& x)     { scanf("%" PRId64, &x); }
void Read(ull& x)    { scanf("%" PRIu64, &x); }
void Read(float& x)  { scanf("%f", &x);       }
void Read(double& x) { scanf("%lf", &x);      }
void Read(string& x) { cin >> x;              }
void Read(char& x)   { scanf("%c", &x);       }
template<class ...T> void Read(int& x, T& ...args)    { scanf("%d", &x);        Read(args...); }
template<class ...T> void Read(uint& x, T& ...args)   { scanf("%u", &x);        Read(args...); }
template<class ...T> void Read(ll& x, T& ...args)     { scanf("%" PRId64, &x);  Read(args...); }
template<class ...T> void Read(ull& x, T& ...args)    { scanf("%" PRIu64, &x);  Read(args...); }
template<class ...T> void Read(float& x, T& ...args)  { scanf("%f", &x);        Read(args...); }
template<class ...T> void Read(double& x, T& ...args) { scanf("%lf", &x);       Read(args...); }
template<class ...T> void Read(string& x, T& ...args) { cin >> x;               Read(args...); }
template<class ...T> void Read(char& x, T& ...args)   { scanf("%c", &x);        Read(args...); }

// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  Utility                                                                                                                   /
// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename T> int Size(T elem) { return static_cast<int>(elem.size()); }

// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  main                                                                                                                      /
// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool visit[100002] = { };
int n, m;
vector<int> G[100002];

int path(int depth, int v, int* log) {
  log[depth] = v;
  visit[v] = true;
  int min_deg = 0;
  int min_deg_u = -1;
  for (auto u : G[v]) {
    if (visit[u]) {
      continue;
    }
    int s = Size(G[u]);
    if (min_deg_u == -1 || s < min_deg) {
      min_deg = s;
      min_deg_u = u;
    }
  }
  if (min_deg_u == -1) {
    return depth;
  }
  return path(depth + 1, min_deg_u, log);
}

int path_back(int depth, int v, int* log) {
  *(log - depth) = v;
  visit[v] = true;
  int min_deg = 0;
  int min_deg_u = -1;
  for (auto u : G[v]) {
    if (visit[u]) {
      continue;
    }
    int s = Size(G[u]);
    if (min_deg_u == -1 || s < min_deg) {
      min_deg = s;
      min_deg_u = u;
    }
  }
  if (min_deg_u == -1) {
    return depth;
  }
  return path_back(depth + 1, min_deg_u, log);
}


int main() {
  Read(n, m);
  for (int i = 0; i < m; i++) {
    int a, b;
    Read(a, b);
    G[a].push_back(b);
    G[b].push_back(a);
  }

  int deg_min_index = -1;
  int deg_min = -1;

  for (int i = 1; i < n; i++) {
    int s = Size(G[i]);
    if (deg_min_index == -1 || s < deg_min) {
      deg_min_index = i;
      deg_min = s;
    }
  }

  static int log[200002];
  int depth1 = path(0, deg_min_index, log + 100000);
  int depth2 = path_back(0, deg_min_index, log + 100000);
  int depth = depth1 + depth2;
  Print(depth + 1);
  for (int i = 0; i <= depth; i++) {
    cout << *(log + 100000 - depth2 + i) << " ";
  }
  cout << endl;

  return 0;
}
/* */

Measured memory_bytes: 6784