#pragma GCC optimize("Ofast")

#include <iostream>
#include <vector>

int n, m, k;
std::vector<std::vector<int>> adj;
std::vector<std::vector<int>> mat;
std::vector<int> low_degree_inds;
std::vector<int> sol;
int sol_tot;

bool backtrack() {
    int start = sol.size() == 0 ? 0 : sol.back() + 1;
    for(int i = start; i < low_degree_inds.size(); i++) {
        int ind = low_degree_inds[i];
        int add_degree = adj[ind].size();
        for(int j : sol) {
            add_degree -= mat[ind][low_degree_inds[j]];
        }
        if(add_degree > 0 && sol_tot + add_degree <= k) {
            sol.push_back(i);
            sol_tot += add_degree;
            if(sol_tot == k) {
                return true;
            }
            if(backtrack()) {
                return true;
            }
            sol.pop_back();
            sol_tot -= add_degree;
        }
    }
    return false;
}

int main() {
    std::cin >> n >> m >> k;
    adj = std::vector<std::vector<int>>(n, std::vector<int>());
    mat = std::vector<std::vector<int>>(n, std::vector<int>(n, 0));
    low_degree_inds = {};
    sol = {};
    sol_tot = 0;

    for(int i = 0; i < m; i++) {
        int a, b;
        std::cin >> a >> b;
        a--;
        b--;
        adj[a].push_back(b);
        adj[b].push_back(a);
        mat[a][b] += 1;
        mat[b][a] += 1;
    }

    for(int i = 0; i < n; i++) {
        if(adj[i].size() <= k) {
            low_degree_inds.push_back(i);
        }
    }

    if(backtrack()) {
        std::cout << sol.size() << std::endl;
        for(int j : sol) {
            std::cout << (low_degree_inds[j] + 1) << " ";
        }
        std::cout << std::endl;
    }
    else {
        std::cout << "impossible" << std::endl;
    }
}