#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cfloat>

using std::cerr;
using std::cin;
using std::cout;
using std::endl;

template<typename CostType>
/// \brief 辺の情報
struct Edge{
  int      to;
  CostType cost;

  Edge(int t, CostType c): to(t), cost(c){
  }
};

template<typename CostType>
class Graph{

private:

  /// \brief adjacent_list_[n]=ノードnの隣接リストを表すvector<Edge>
  std::vector<std::vector<Edge<CostType>>> adjacent_list_;

public:

  /// \brief 頂点数
  const int NODE_SIZE_;

  /// \brief コンストラクタ
  /// \param node_size 頂点数
  explicit Graph(const int node_size): NODE_SIZE_(node_size),
                                       adjacent_list_(node_size){
  }

  /// \brief 有向グラフの辺を生やす
  /// \param from 辺の根本の頂点の番号
  /// \param to 辺の先の頂点の番号
  /// \param cost 辺のコスト
  void SetDirectedEdge(const int from, const int to, const CostType cost){
    adjacent_list_[from].push_back(Edge<CostType>(to, cost));
  }

  /// \brief 無向グラフの辺を生やす
  /// \param node_a 一方の頂点の番号
  /// \param node_b もう一方の頂点の番号
  /// \param cost 辺のコスト
  void
  SetUndirectedEdge(const int node_a, const int node_b, const CostType cost){
    SetDirectedEdge(node_a, node_b, cost);
    SetDirectedEdge(node_b, node_a, cost);
  }

  /// \brief ある頂点の隣接リストを取得
  /// \param node_num 頂点の番号
  /// \return 隣接リスト
  std::vector<Edge<CostType>> GetAdjacentList(int node_num) const{
    return adjacent_list_[node_num];
  }
};

enum State{
  unknown,red,blue
};

void Solve(int n,int m){
  Graph<int> graph(n);
  for(int i=0;i<m;i++){
    int u,v;
    cin>>u>>v;
    graph.SetUndirectedEdge(u-1,v-1,1);
  }

  std::vector<State> state(n);

  for(int i=0;i<n;i++){
    state[i]=unknown;
  }

  state[0]=red;

  std::queue<int> q;
  q.push(0);
  while(!q.empty()){
    int curr=q.front();
    q.pop();
    for(auto e:graph.GetAdjacentList(curr)){
      if(state[e.to]==unknown){
        if(state[curr]==red){
          state[e.to]=blue;
          q.push(e.to);
        }else{
          state[e.to]=red;
          q.push(e.to);
        }
      }else if(state[e.to]==red){
        if(state[curr]==red){
          cout<<0<<endl;
          return;
        }
      }else{
        if(state[curr]==blue){
          cout<<0<<endl;
          return;
        }

      }
    }
  }

  int red_count=0,blue_count=0;
  for(auto node:state){
    if(node==red){
      red_count++;
    }else{
      blue_count++;
    }
  }

  if(red_count%2==0&&blue_count%2==0){
    int pa=red_count/2;
    int pb=blue_count/2;
    if(pa==pb){
      cout<<1<<endl;
      cout<<pa<<endl;
    }else{
      cout<<2<<endl;
      cout<<std::min(pa,pb)<<endl;
      cout<<std::max(pa,pb)<<endl;
    }
  }else if(red_count%2==1&&blue_count%2==1){
    cout<<0<<endl;
  }else{
    cout<<1<<endl;
    if(red_count%2==0){
      cout<<red_count/2<<endl;
    }else{
      cout<<blue_count/2<<endl;
    }
  }

}

int main(){
  cout << std::fixed << std::setprecision(16);
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);

  while(true){
    int n,m;
    cin>>n>>m;
    if(n==0) break;
    Solve(n,m);
  }







  return 0;
}


Measured memory_bytes: 3248