import java.util.*

var adj: Array<IntArray> = Array(0) { IntArray(0) }
var deg: IntArray = IntArray(0)

fun bf(A: List<Int>, i: Int, R: MutableList<Int>, c: Int): Boolean {
    if (c == 0) {
        println(R.size)
        for (j in R.indices) {
            print((R[j] + 1).toString() + (if (j == R.size - 1) "\n" else " "))
        }
        return true
    }
    if (i == A.size) {
        return false
    }
    var d = deg[A[i]]
    for (r in R) {
        d -= adj[r][A[i]]
    }
    if (bf(A, i + 1, R, c)) return true
    if (d in 1..c) {
        R.add(A[i])
        if (bf(A, i + 1, R, c - d)) return true
        R.removeAt(R.size - 1)
    }
    return false
}

fun main() {
    val (n, m, k) = readln().split(" ").map { it.toInt() }
    adj = Array(n) { IntArray(n) }
    deg = IntArray(n)
    for (i in 0 until m) {
        val (a, b) = readln().split(" ").map { it.toInt() - 1 }
        adj[a][b]++
        adj[b][a]++
        deg[a]++
        deg[b]++
    }

    // Check size 1 subsets
    for (i in 0 until n) {
        if (deg[i] == k) {
            println(1)
            println(i + 1)
            return
        }
    }

    // Check size 2 subsets
    for (i in 0 until n) {
        for (j in i + 1 until n) {
            if (deg[i] + deg[j] - adj[i][j] == k) {
                println(2)
                println((i + 1).toString() + " " + (j + 1))
                return
            }
        }
    }

    // Check size 3 subsets with a degree k-2 vertex
    for (i in 0 until n) {
        if (deg[i] != k - 2) continue
        val A: MutableList<Int> = ArrayList()
        for (j in 0 until n) {
            if (i == j) continue
            if (deg[j] - adj[i][j] == 1) {
                A.add(j)
            }
        }
        if (A.size >= 2 && adj[A[0]][A[1]] == 0) {
            println(3)
            println((i + 1).toString() + " " + (A[0] + 1) + " " + (A[1] + 1))
            return
        }
        if (A.size >= 3) {
            println(3)
            println((i + 1).toString() + " " + (A[0] + 1) + " " + (A[2] + 1))
            return
        }
    }

    if (k <= 3) {
        println("impossible")
        return
    }

    // Collect low degree vertices
    val A: MutableList<MutableList<Int>> = ArrayList()
    for (i in 0 until k - 3) {
        A.add(ArrayList())
    }
    for (i in 0 until n) {
        if (deg[i] in 1..k - 3) A[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[0].isEmpty()) {
        var pos = false
        for (i in A[1].indices) {
            for (j in i + 1 until A[1].size) {
                if (adj[A[1][i]][A[1][j]] == 1) {
                    pos = true
                    Collections.swap(A[1], 0, i)
                    Collections.swap(A[1], 1, j)
                    break
                }
            }
            if (pos) break
        }
        if (!pos) {
            println("impossible")
            return
        }
    }

    // Brute force the remainder
    val B: MutableList<Int> = ArrayList()
    val R: MutableList<Int> = ArrayList()
    for (i in 0 until k - 3) {
        for (a in A[i]) {
            B.add(a)
        }
    }
    B.reverse()
    if (!bf(B, 0, R, k)) {
        println("impossible")
    }
}