/*#include <bits/stdc++.h>

using namespace std;
int n,k;
struct Bencu {
    int apa;
    int ido;
}a[10001];

int main()
{
    ifstream f("be.in");
    cin>>n>>k;
    for (int i=2; i<=n; i++) {
        cin>>a[i].apa>>a[i].ido;
    }
    cout<<0;
    return 0;
}*/
#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>

using namespace std;

const int MAX_N = 100000;
vector<int> adj[MAX_N + 1];
bool valid[MAX_N + 1];

void bfs(int start, int K, set<int>& component) {
    queue<int> q;
    q.push(start);
    component.insert(start);

    while (!q.empty()) {
        int node = q.front();
        q.pop();

        for (int neighbor : adj[node]) {
            if (valid[neighbor] && component.find(neighbor) == component.end()) {
                component.insert(neighbor);
                q.push(neighbor);
            }
        }
    }
}

int main() {
    int N, M, K;
    cin >> N >> M >> K;

    for (int i = 1; i <= N; i++) {
        valid[i] = true;
    }

    for (int i = 0; i < M; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // Eltávolítjuk azokat a csúcsokat, amelyeknek kevesebb mint K szomszédjuk van
    queue<int> removeQueue;
    for (int i = 1; i <= N; i++) {
        if ((int)adj[i].size() < K) {
            removeQueue.push(i);
        }
    }

    while (!removeQueue.empty()) {
        int node = removeQueue.front();
        removeQueue.pop();
        valid[node] = false;

        for (int neighbor : adj[node]) {
            if (valid[neighbor]) {
                adj[neighbor].erase(remove(adj[neighbor].begin(), adj[neighbor].end(), node), adj[neighbor].end());
                if ((int)adj[neighbor].size() < K) {
                    removeQueue.push(neighbor);
                }
            }
        }
    }

    // Megkeressük a legnagyobb K-biztonságos összefüggő komponenset
    set<int> largestComponent;

    for (int i = 1; i <= N; i++) {
        if (valid[i]) {
            set<int> component;
            bfs(i, K, component);

            if (component.size() > largestComponent.size()) {
                largestComponent = component;
            }
        }
    }

    // Kiírjuk az eredményt
    cout << largestComponent.size() << endl;
    for (int node : largestComponent) {
        cout << node << " ";
    }
    cout << endl;

    return 0;
}