import kotlin.math.ln
import kotlin.math.min
import kotlin.math.pow
import kotlin.random.Random

fun main() {
    val rng = Random(System.currentTimeMillis())

    val (n, m, k) = readln().split(" ").map { it.toInt() }

    val adj: MutableList<MutableList<Int>> = ArrayList(n)
    val deg = IntArray(n)
    for (i in 0 until n) {
        adj.add(ArrayList())
    }

    for (i in 0 until m) {
        val (u, v) = readln().split(" ").map { it.toInt() - 1 }
        adj[u].add(v)
        adj[v].add(u)
        deg[u]++
        deg[v]++
    }

    val error = 0.0001
    val samples = min(3000, (ln(error) / ln(1 - 4.0.pow(-k.toDouble()))).toInt())
    for (z in 0 until samples) {
        val green = BooleanArray(n)
        for (i in 0 until n) {
            if (deg[i] <= k) {
                green[i] = rng.nextInt(2) == 1
            }
        }
        val vis = BooleanArray(n)
        val components: MutableList<List<Int>> = ArrayList()
        for (i in 0 until n) {
            if (green[i] && !vis[i]) {
                val component: MutableList<Int> = ArrayList()
                component.add(i)
                vis[i] = true
                var j = 0
                while (j < component.size) {
                    for (v in adj[component[j]]) {
                        if (green[v] && !vis[v]) {
                            component.add(v)
                            vis[v] = true
                        }
                    }
                    j++
                }
                components.add(component)
            }
        }
        val edges = IntArray(components.size)
        for (i in components.indices) {
            for (u in components[i]) {
                for (v in adj[u]) {
                    edges[i] += if ((!green[v] || u < v)) 1 else 0
                }
            }
        }

        val dp = Array(components.size + 1) {
            BooleanArray(k + 1)
        }
        dp[0][0] = true
        for (i in components.indices) {
            for (j in 0..k) {
                dp[i + 1][j] = dp[i + 1][j] or dp[i][j]
                if (j + edges[i] <= k) {
                    dp[i + 1][j + edges[i]] = dp[i + 1][j + edges[i]] or dp[i][j]
                }
            }
        }
        if (!dp[components.size][k]) continue
        val ans: MutableList<Int> = ArrayList()
        run {
            var i = components.size
            var j = k
            while (i > 0 && j > 0) {
                if (dp[i][j] && !dp[i - 1][j]) {
                    ans.addAll(components[i - 1])
                    j -= edges[i - 1]
                }
                i--
            }
        }
        println(ans.size)
        for (i in ans) {
            println(i + 1)
        }
        return
    }
    println("impossible")
}