#!/usr/bin/env python3
import sys

sys.setrecursionlimit(10_000)


def bf(A, i, R, c):
    if c == 0:
        print(len(R))
        print(" ".join(str(x + 1) for x in R))
        return True
    if i == len(A):
        return False
    d = deg[A[i]]
    for r in R:
        d -= adj[r][A[i]]
    if bf(A, i + 1, R, c):
        return True
    if 0 < d <= c:
        R.append(A[i])
        if bf(A, i + 1, R, c - d):
            return True
        R.pop()
    return False


n, m, k = map(int, input().split())
adj = [[0] * n for _ in range(n)]
deg = [0] * n
for _ in range(m):
    a, b = map(int, input().split())
    adj[a - 1][b - 1] += 1
    adj[b - 1][a - 1] += 1
    deg[a - 1] += 1
    deg[b - 1] += 1

# Check size 1 subsets
for i in range(n):
    if deg[i] == k:
        print(1)
        print(i + 1)
        exit()

# Check size 2 subsets
for i in range(n):
    for j in range(i + 1, n):
        if deg[i] + deg[j] - adj[i][j] == k:
            print(2)
            print(i + 1, j + 1)
            exit()

# Check size 3 subsets with a degree k-2 vertex
for i in range(n):
    if deg[i] != k - 2:
        continue
    A = []
    for j in range(n):
        if i == j:
            continue
        if deg[j] - adj[i][j] == 1:
            A.append(j)
    if len(A) >= 2 and adj[A[0]][A[1]] == 0:
        print(3)
        print(i + 1, A[0] + 1, A[1] + 1)
        exit()
    if len(A) >= 3:
        print(3)
        print(i + 1, A[0] + 1, A[2] + 1)
        exit()

if k <= 3:
    print("impossible")
    exit()

# Collect low degree vertices
A = [[] for _ in range(k - 3)]
for i in range(n):
    if 0 < deg[i] <= k - 3:
        A[deg[i] - 1].append(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 and len(A[0]) == 0:
    pos = False
    for i in range(len(A[1])):
        for j in range(i + 1, len(A[1])):
            if adj[A[1][i]][A[1][j]] == 1:
                pos = True
                A[1][0], A[1][i] = A[1][i], A[1][0]
                A[1][1], A[1][j] = A[1][j], A[1][1]
                break
        if pos:
            break
    if not pos:
        print("impossible")
        exit()

# Brute force the remainder
B, R = [], []
for i in range(k - 3):
    for a in A[i]:
        B.append(a)
B.reverse()
if not bf(B, 0, R, k):
    print("impossible")