#include <stdio.h>
#include <math.h>
#define N 200000
#include <vector>
#include <stack>

using namespace std;
//int deg[]
//state[] - 0 - ok, 1 - in queue, 2 - deleted
/*
1. init deg, state
2. while (queue/sth not empty) {
        get first
        sprawdz sasiadow: czy ktorys ma stan = 0 && deg == d (tzn. czy mu teraz spadnie ponizej d)
    }
3. znalezc najwieksza spojna skladowa
 */
vector<int> adj[N+1];
int deg[N+1];
int state[N+1];
vector<int> vertices_to_delete;
int connected_cout = 0;

int vertex_component_id[N+1];
int visited[N+1];
int component_size[N+1];


void print_list_to_delete(int n) {
    printf("Lista wierzcholkow do usuniecia\n");
    for(vector<int>::iterator it = vertices_to_delete.begin(); it != vertices_to_delete.end(); ++it) {
        /* std::cout << *it; ... */
        printf("%d\n", *it);
    }
}

int main() {
    int n, m, d;
    scanf("%d %d %d", &n, &m, &d);

    for (int i = 0; i < m; ++i) {
        int v, u;
        scanf("%d %d", &v, &u);
        adj[v].push_back(u);
        adj[u].push_back(v);
    }

    for (int i = 1; i <= n; ++i) {
        visited[i] = 0;
        vertex_component_id[i] = -1;
        deg[i] = adj[i].size();
        if (deg[i] < d) {
            //printf("usunê wierzcholek %d\n",i);
            vertices_to_delete.push_back(i);
            state[i] = 1;
        } else {
            state[i] = 0;
        }

    }

    for (int i = 1; i <= n; ++i) {
        //printf("wierzcholek %d ma stopien = %d\n", i, deg[i]);
    }

    //print_list_to_delete(n);

    while (!vertices_to_delete.empty()) {
        int v = vertices_to_delete.back();
        //printf("usuwam wierzcholek %d\n",v);
        vertices_to_delete.pop_back();

        state[v] = 2;

        for(vector<int>::iterator it = adj[v].begin(); it != adj[v].end(); ++it) {
            int u = *it;
            deg[u]--;

            if (state[u] == 0 && deg[u] < d) {
                //printf("usunê wierzcholek %d\n",u);
                vertices_to_delete.push_back(u);
                state[u] = 1;
            }

        }
    }

    stack<int> vertexes_to_visit;

    for (int i = 1; i <= n; ++i) {


        if (state[i] == 0 && visited[i] == 0) {
            //printf("dodaje wierzcholek %d\n",i);

            vertexes_to_visit.push(i);

            connected_cout++;
            component_size[connected_cout] = 0;

            while (!vertexes_to_visit.empty()) {
                int v = vertexes_to_visit.top();
                vertexes_to_visit.pop();

                //printf("odwiedzam wierzcholek %d\n",v);


                visited[v] = 2;
                vertex_component_id[v] = connected_cout;
                component_size[connected_cout]++;

                for(vector<int>::iterator it = adj[v].begin(); it != adj[v].end(); ++it) {
                    int u = *it;
                    if (state[u] == 0 && visited[u] == 0) {
                        visited[u] = 1;
                        vertexes_to_visit.push(u);
                        //printf("dodaje wierzcholek %d\n",u);

                    }
                }
            }
        }
    }

    int max_component_id;
    int max_component_size = -1;
    for (int i = 1; i <= connected_cout ; ++i) {
        //printf("skladowa %d ma rozmiar %d\n", i, component_size[i]);
        //printf("%d < %d ?\n", max_component_size, component_size[i]);
        if (max_component_size < component_size[i]) {
            max_component_id = i;
            max_component_size = component_size[i];
        }
    }


    for (int i = 1; i <=n ; ++i) {
        //printf("wierzcholek %d w skladowej %d\n", i, vertex_component_id[i]);
    }

    //printf("max skladowa ma rozmiar: %d (id = %d)\n", max_component_size, max_component_id);

    if (max_component_size == -1) {
        printf("NIE");
    } else {
        printf("%d\n", max_component_size);
        for (int i = 1; i <= n ; ++i) {
            if (vertex_component_id[i] == max_component_id) {
                printf("%d ", i);
            }
        }
    }

    return 0;
}