import java.util.*;

public class mis {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nodes = scanner.nextInt();
        int edges = scanner.nextInt();
        int K = scanner.nextInt();
        Solution solution = new Solution(K, nodes);

        for (int i = 0; i < edges; i++) {
            solution.addEdge(scanner.nextInt() - 1, scanner.nextInt() - 1);
        }
        solution.commit();

        solution.reduceNodes();
        solution.findMaxSubGraph();
        if (solution.foundGraph()) {
            Collection<Node> result = solution.getFoundNodes();
            System.out.println(result.size());
            for (Node node : result) {
                System.out.print((node.id + 1) + " ");
            }
            System.out.println();
        } else {
            System.out.println("NIE");
        }
    }

    private static class Solution {
        private int K;
        private Node[] nodes;
        private LinkedList<Node> nodesLL;
        private List<Node> maxSubGraph;

        public Solution(int K, int nodesCount) {
            this.K = K;
            this.nodes = new Node[nodesCount];
            for (int i = 0; i < nodesCount; i++) {
                this.nodes[i] = new Node(i);
            }
            this.nodesLL = new LinkedList<>();
        }

        public void addEdge(int from, int to) {
            this.nodes[from].addEdge(to);
            this.nodes[to].addEdge(from);
        }

        public void commit() {
            Collections.addAll(this.nodesLL, this.nodes);
        }

        public void reduceNodes() {
            boolean done = false;

            while (!done) {
                done = true;
                ListIterator<Node> i = nodesLL.listIterator();
                while (i.hasNext()) {
                    Node node = i.next();
                    if (node.getEdgesCount() < K) {
                        done = false;
                        removeEdges(node);
                        i.remove();
                    }
                }
            }
        }

        private void removeEdges(Node node) {
            for (int neighbor : node.neighbors) {
                nodes[neighbor].removeEdge(node.id);
            }
        }

        public void findMaxSubGraph() {
            Node node;

            while ((node = findUncheckedNode()) != null) {
                List<Node> subGraph = calculateGraphNodes(node);
                if (maxSubGraph == null || maxSubGraph.size() < subGraph.size()) {
                    maxSubGraph = subGraph;
                }
            }

            if (maxSubGraph != null) {
                maxSubGraph.sort(new Comparator<Node>() {
                    @Override
                    public int compare(Node o1, Node o2) {
                        return o1.id - o2.id;
                    }
                });
            }
        }

        private List<Node> calculateGraphNodes(Node node) {
            node.check();
            LinkedList<Node> queue = new LinkedList<>();
            queue.add(node);
            LinkedList<Node> result = new LinkedList<>();

            while (!queue.isEmpty()) {
                node = queue.poll();
                result.push(node);
                for (int neighborId : node.neighbors) {
                    Node neighbor = nodes[neighborId];
                    if (!neighbor.isChecked()) {
                        neighbor.check();
                        queue.add(neighbor);
                    }
                }
            }
            return result;
        }

        private Node findUncheckedNode() {
            for (Node node : nodesLL) {
                if (!node.isChecked()) {
                    return node;
                }
            }
            return null;
        }

        public List<Node> getFoundNodes() {
            return maxSubGraph;
        }

        public boolean foundGraph() {
            return maxSubGraph != null;
        }
    }

    private static class Node {

        private int id;
        private LinkedList<Integer> neighbors;
        private boolean checked;

        public Node(int id) {
            this.id = id;
            this.neighbors = new LinkedList<>();
            this.checked = false;
        }

        public void addEdge(int target) {
            neighbors.add(target);
        }

        public int getEdgesCount() {
            return neighbors.size();
        }

        public void removeEdge(int id) {
            neighbors.remove(new Integer(id));
        }

        public boolean isChecked() {
            return checked;
        }

        public void check() {
            checked = true;
        }
    }
}