import java.io.*;
import java.util.*;

public class ReinierAltTranscribed {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            new ReinierAltTranscribed().run(new Scanner(reader));
        }
    }

    int[][] adj;
    int[] deg;

    boolean bf(List<Integer> A, int i, List<Integer> R, int c) {
        if (c == 0) {
            System.out.println(R.size());
            for (int j = 0; j < R.size(); j++) {
                System.out.print((R.get(j) + 1) + (j == R.size() - 1 ? "\n" : " "));
            }
            return true;
        }
        if (i == A.size()) {
            return false;
        }
        int d = deg[A.get(i)];
        for (int r : R) {
            d -= adj[r][A.get(i)];
        }
        if (bf(A, i + 1, R, c)) return true;
        if (d > 0 && d <= c) {
            R.add(A.get(i));
            if (bf(A, i + 1, R, c - d)) return true;
            R.remove(R.size() - 1);
        }
        return false;
    }

    void run(Scanner scanner) {
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int k = scanner.nextInt();
        adj = new int[n][n];
        deg = new int[n];
        for (int i = 0; i < m; i++) {
            int a = scanner.nextInt() - 1;
            int b = scanner.nextInt() - 1;
            adj[a][b]++;
            adj[b][a]++;
            deg[a]++;
            deg[b]++;
        }

        // Check size 1 subsets
        for (int i = 0; i < n; i++) {
            if (deg[i] == k) {
                System.out.println(1);
                System.out.println(i + 1);
                return;
            }
        }

        // Check size 2 subsets
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (deg[i] + deg[j] - adj[i][j] == k) {
                    System.out.println(2);
                    System.out.println((i + 1) + " " + (j + 1));
                    return;
                }
            }
        }

        // Check size 3 subsets with a degree k-2 vertex
        for (int i = 0; i < n; i++) {
            if (deg[i] != k - 2) continue;
            List<Integer> A = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                if (i == j) continue;
                if (deg[j] - adj[i][j] == 1) {
                    A.add(j);
                }
            }
            if (A.size() >= 2 && adj[A.get(0)][A.get(1)] == 0) {
                System.out.println(3);
                System.out.println((i + 1) + " " + (A.get(0) + 1) + " " + (A.get(1) + 1));
                return;
            }
            if (A.size() >= 3) {
                System.out.println(3);
                System.out.println((i + 1) + " " + (A.get(0) + 1) + " " + (A.get(2) + 1));
                return;
            }
        }

        if (k <= 3) {
            System.out.println("impossible");
            return;
        }

        // Collect low degree vertices
        List<List<Integer>> A = new ArrayList<>();
        for (int i = 0; i < k - 3; i++) {
            A.add(new ArrayList<>());
        }
        for (int i = 0; i < n; i++) {
            if (0 < deg[i] && deg[i] <= k - 3) A.get(deg[i] - 1).add(i);
        }

        // If k = 5 and there are no degree 1 vertices, ensure that
        // A[1] starts with two adjacent degree 2 vertices.
        if (k == 5 && A.get(0).isEmpty()) {
            boolean pos = false;
            for (int i = 0; i < A.get(1).size(); i++) {
                for (int j = i + 1; j < A.get(1).size(); j++) {
                    if (adj[A.get(1).get(i)][A.get(1).get(j)] == 1) {
                        pos = true;
                        Collections.swap(A.get(1), 0, i);
                        Collections.swap(A.get(1), 1, j);
                        break;
                    }
                }
                if (pos) break;
            }
            if (!pos) {
                System.out.println("impossible");
                return;
            }
        }

        // Brute force the remainder
        List<Integer> B = new ArrayList<>();
        List<Integer> R = new ArrayList<>();
        for (int i = 0; i < k - 3; i++) {
            for (int a : A.get(i)) {
                B.add(a);
            }
        }
        Collections.reverse(B);
        if (!bf(B, 0, R, k)) {
            System.out.println("impossible");
        }
    }
}