//Jakub Staroń
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <stdexcept>
#include <unordered_map>
#include <unordered_set>

#ifdef COMPILING_HOME
#define DEBUG_MODE
#endif

using namespace std;

typedef char int8;
typedef unsigned char uint8;
typedef short int int16;
typedef unsigned short int uint16;
typedef int int32;
typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;

typedef std::pair<int32,int32> int32_pair;
typedef std::pair<uint32, uint32> uint32_pair;
typedef std::pair<int64,int64> int64_pair;
typedef std::pair<uint64,uint64> uint64_pair;

typedef std::vector<bool> bit_vector;

#ifdef DEBUG_MODE
#define debug_print(x) cerr << #x << " = " << x << endl
#define print_line cerr << "Line " << __LINE__ << endl
#include <cassert>
#else
#define debug_print(x)
#define print_line
#define assert(x)
#endif

#define rep(i, x) for(int32 i = 0 ; i < (x) ; i++)
#define for_range(i, begin, end) for(auto i = (begin) ; i != (end) ; ++i )
#define all(c) (c).begin(),(c).end()
#define sort_all(x) sort( all(x) )
#define divide(a, b) ( ( (b)%(a) ) == 0 )
#define mp(x, y) make_pair(x,y)
#define pb(x) push_back(x)

#define sig(x) ( (x) == 0 ? 0 : ( (x) < 0 ? -1 : 1 ) )

const double epsilon = 1e-5;

template<class T>
void unique(std::vector<T>& v) {
	sort_all(v);
	v.resize( std::unique(all(v)) - v.begin() );
}

ostream& newline(ostream& str) {
	str.put('\n');
	return str;
}

template<typename T1, typename T2>
istream& operator>>(istream& stream, std::pair<T1, T2>& pair) {
	stream >> pair.first >> pair.second;
	return stream;
}

template<typename T1, typename T2>
ostream& operator<<(ostream& stream, const std::pair<T1, T2>& pair) {
#ifdef DEBUG_MODE
	stream << "(" << pair.first << ", " << pair.second << ")";
#else
	stream << pair.first << ' ' << pair.second;
#endif
	return stream;
}

template<class T>
inline pair<T,T> operator+(const pair<T,T>& a, const pair<T,T>& b) {
	return pair<T,T>(a.first + b.first, a.second + b.second);
}

template<class T>
inline pair<T,T> operator-(const pair<T,T>& a, const pair<T,T>& b) {
	return pair<T,T>(a.first - b.first, a.second - b.second);
}

template<class T>
ostream& operator<<(ostream& str, const vector<T>& v) {
	if(!v.empty())	{
		for(int32 i = 0 ; i + 1 < v.size() ; i++)		
			str << v[i] << ' ';		
		str << v.back();
	}
	return str;
}

class Graf {
public:
	typedef set<uint32> list_type;

	void resize(uint32 k) {
		graf.resize(k);
	}

	void add(uint32 a, uint32 b) {
		graf[a].insert(b);
		graf[b].insert(a);
	}

  void remove(uint32 a) {
    for (uint32 v : obok(a))
      graf[v].erase(a);

    graf[a].clear();
  }

  void remove(uint32 a, uint32 b) {
    graf[a].erase(b);
    graf[b].erase(a);
  }

	uint32 deg(uint32 k) {
		return graf[k].size();
	}

	list_type& obok(uint32 k) {
		return graf[k];
	}

	uint32 size() {
		return graf.size();
	}

private:
	vector<list_type> graf;
};

class Application {
public:
	Application() { 
	}

	void Run() {
		WczytajDane();

    set<uint32> to_delete;
    rep (i, N)
      if (graf.deg(i) < D)
        to_delete.insert(i);

    while (!to_delete.empty()) {
      uint32 v = *to_delete.begin();
      to_delete.erase(to_delete.begin());

      for (uint32 u : graf.obok(v))
        if (graf.deg(u) <= D) // after erasing of v will have one less
          to_delete.insert(u);

      graf.remove(v);
      removed[v] = true;
    }

    uint32 component_index = 1;
    rep(i, N)
      if (!visited[i] && !removed[i])
        BFS(i, component_index++);

    vector<uint32> component_sizes(N + 1);
    rep(i, N) {
      if (visited[i])
        component_sizes[visited[i]]++;
    }

    uint32 max_index = max_element(all(component_sizes)) - component_sizes.begin();
    if (component_sizes[max_index] == 0) {
      cout << "NIE" << newline;
      return;
    }

    vector<uint32> result;
    rep(i, N) {
      if (visited[i] == max_index)
        result.push_back(i);
    }

    cout << result.size() << newline;
    for (uint32 v : result)
      cout << (v + 1) << ' ';
	}

  void BFS(uint32 start, uint32 component_index) {
    vector<uint32> Q;
    Q.push_back(start);
    visited[start] = component_index;

    while (!Q.empty()) {
      uint32 v = Q.back();
      Q.pop_back();

      for (uint32 u : graf.obok(v)) {
        if (!visited[u]) {
          visited[u] = component_index;
          Q.push_back(u);
        }
      }
    }
  }

	void WczytajDane() {
		cin >> N >> M >> D;
		graf.resize(N);
    removed.assign(N, false);
    visited.assign(N, 0);
		rep(i, M) {
      uint32 a, b;
      cin >> a >> b;
      a--, b--;
      graf.add(a, b);
		}
	}

  vector<uint32> visited;
  bit_vector removed;
	uint32 N, M, D;
  Graf graf;
};


int main() {
	ios::sync_with_stdio(0);
	Application application;
	application.Run();
	return 0;
}