#include <vector>
#include <iostream>
#include <random>
#include <chrono>
#include <algorithm>
#include <ranges>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) begin(x), end(x)
#define sz(x) ssize(x)

using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;

using vvi = vector<vi>;

struct edge {
    int u, v;
    bool directed = true;
};

int main() {
    cin.tie(0)->sync_with_stdio(0);
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    auto three_sided_die = uniform_int_distribution<int>(0, 2); // hehe

    int n, m, k; cin >> n >> m >> k;

    vector<edge> edges(m);
    rep(i, m) {
        int u, v; cin >> u >> v;
        u--, v--;
        edges[i] = {u, v};
    }

    double error = 0.0001;
    int samples = min(3000, static_cast<int>(log(error) / log(1 - pow(3, -k))));
    rep(_, samples) {
        vvi adj(n), adj_undirected(n);
        rep(i, m) {
            edges[i].directed = true;
            auto roll = three_sided_die(rng);
            if (roll == 0) edges[i].directed = false;
            if (roll == 1) swap(edges[i].u, edges[i].v);

            adj[edges[i].u].push_back(edges[i].v);
            adj[edges[i].v].push_back(edges[i].u);
            if (!edges[i].directed) {
                adj_undirected[edges[i].v].push_back(edges[i].u);
                adj_undirected[edges[i].u].push_back(edges[i].v);
            }
        }
        vi outdeg(n);
        rep(i, m) if (edges[i].directed) outdeg[edges[i].u]++;
        vector<bool> vis(n);
        vvi components;
        rep(i, n) if (!vis[i]) {
                vector component = {i};
                vis[i] = true;
                rep(j, sz(component))
                    for (int v : adj_undirected[component[j]]) if (!vis[v]) {
                            component.push_back(v);
                            vis[v] = true;
                        }
                components.push_back(component);
            }
        erase_if(components, [&](const auto& comp) {
            return comp.empty() or ranges::any_of(comp, [&](int x) { return outdeg[x] > 0; });
        });
        vector<bool> green(n);
        for (const auto& comp : components) for (int x : comp) green[x] = true;
        vi covered(sz(components));
        rep(i, sz(components))
            for (int u : components[i])
                for (int v : adj[u])
                    covered[i] += !green[v] || (u < v);
        vector dp(sz(components) + 1, vector<char>(k + 1, false));
        dp[0][0] = true;
        rep(i, sz(components))
            rep(j, k + 1) {
                dp[i+1][j] |= dp[i][j];
                if (j + covered[i] <= k)
                    dp[i+1][j+covered[i]] |= dp[i][j];
            }
        if (!dp.back().back()) continue;
        vi ans;
        for (int i = sz(components), j = k; i > 0 && j > 0; i--)
            if (dp[i][j] && !dp[i-1][j]) {
                ans.insert(ans.end(), all(components[i-1]));
                j -= covered[i-1];
            }
        cout << sz(ans) << "\n";
        rep(i, sz(ans)) cout << ans[i] + 1 << " \n"[i == sz(ans) - 1];
        return 0;
    }
    cout << "impossible\n";
    return 0;
}