#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <charconv>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <optional>
#include <random>
#include <set>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
#include <queue>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;

#define x first
#define y second
#define pb push_back
#define eb emplace_back
#define rep(i,a,b) for(auto i=(a); i<(b); ++i)
#define REP(i,n) rep(i,0,n)
#define all(v) (v).begin(), (v).end()
#define rs resize
#define DBG(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl

const ld PI = acos(-1.0);
template<class T> using min_queue =
priority_queue<T, vector<T>, greater<T>>;
template<class T> int sz(const T &x) {
    return (int) x.size(); // copy the ampersand(&)!
}

// START OF ACTUAL PROGRAM, START READING HERE

vvi adj;
vi deg;

bool bf(vi A, ll i, vi R, ll c) {
	if (c == 0) {
		cout << R.size() << endl;
		for (int j = 0; j < R.size(); j++) {
			cout << R[j]+1 << (j == R.size() - 1 ? "\n" : " ");
		}
		return true;
	}
	if (i == A.size()) {
		return false;
	}
	ll d = deg[A[i]];
	for (ll r : R) {
		d -= adj[r][A[i]];
	}
	if (bf(A, i+1, R, c)) return true;
	if (d > 0 && d <= c) {
		R.pb(A[i]);
		if (bf(A, i+1, R, c-d)) return true;
		R.pop_back();
	}
	return false;
}

void run() {
	ll n, m, k;
	cin >> n >> m >> k;
	adj = vvi(n, vi(n, 0));
	deg = vi(n, 0);
	for (ll i = 0; i < m; i++) {
		ll a, b;
		cin >> a >> b;
		adj[a-1][b-1]++;
		adj[b-1][a-1]++;
		deg[a-1]++;
		deg[b-1]++;
	}

	// Check size 1 subsets
	for (ll i = 0; i < n; i++) {
		if (deg[i] == k) {
			cout << 1 << endl;
			cout << i+1 << endl;
			return;
		}
	}

	// Check size 2 subsets
	/*for (ll i = 0; i < n; i++) {
		for (ll j = i+1; j < n; j++) {
			if (deg[i] + deg[j] - adj[i][j] == k) {
				cout << 2 << endl;
				cout << i+1 << " " << j+1 << endl;
				return;
			}
		}
	}*/

	// Check size 3 subsets with a degree k-2 vertex
	for (ll i = 0; i < n; i++) {
		if (deg[i] != k-2) continue;
		vi A;
		for (ll j = 0; j < n; j++) {
			if (i == j) continue;
			if (deg[j] - adj[i][j] == 1) {
				A.pb(j);
			}
		}
		vi B;
		if (A.size() >= 2 && adj[A[0]][A[1]] == 0) {
			cout << 3 << endl << i+1 << " " << A[0]+1 << " " << A[1]+1 << endl;
			return;
		}
		if (A.size() >= 3) {
			cout << 3 << endl << i+1 << " " << A[0]+1 << " " << A[2]+1 << endl;
			return;
		}
	}

	if (k <= 3) {
		cout << "impossible" << endl;
		return;
	}

	// Collect low degree vertices
	vvi A(k-3);
	for (ll i = 0; i < n; i++) {
		if (deg[i] <= k-3 && deg[i] > 0) A[deg[i]-1].pb(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].size() == 0) {
		bool pos = false;
		for (ll i = 0; i < A[1].size(); i++) {
			for (ll j = i+1; j < A[1].size(); j++) {
				if (adj[A[1][i]][A[1][j]] == 1) {
					pos = true;
					swap(A[1][0], A[1][i]);
					swap(A[1][1], A[1][j]);
					break;
				}
			}
			if (pos) break;
		}
		if (!pos) {
			cout << "impossible" << endl;
			return;
		}
	}

	// Brute force the remainder
	vi B, R;
	for (ll i = 0; i < k-3; i++) {
		for (ll a : A[i]) {
			B.pb(a);
		}
	}
	reverse(all(B));
	if (!bf(B, 0, R, k)) {
		cout << "impossible" << endl;
	}
}

signed main() {
    // DON'T MIX "scanf" and "cin"!
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout << fixed << setprecision(20);
    run();
    return 0;
}