#include <fstream>
#include <list>
#include <bitset>
#include <deque>
#include <vector>
#include <climits>
#include <algorithm>

using namespace std;

ifstream fin("salvare.in");
ofstream fout("salvare.out");

const int maxV = 1000;
const int Inf = INT_MAX;

list <int> adjList[1 + maxV];

vector <int> degree;
vector <int> dist;

bitset <1 + maxV> seen;
bitset <1 + maxV> marked;
bitset <1 + maxV> solution;

int V, E, K;

void resizeVectors() {

    degree.resize(V + 1);
    dist.resize(V + 1);
}

inline int check(const int &currDist) {

    deque <int> Queue;

    marked.reset();
    seen.reset();

    fill(dist.begin(), dist.end(), Inf);
    for (int node = 1; node <= V; ++node)
        if (degree[node] == 1) {

            Queue.push_back(node);
            dist[node] = currDist;
            seen[node] = true;
        }

    int usedNodes = 0;
    while (!Queue.empty()) {

        int node = Queue.front();
        Queue.pop_front();

        if(dist[node] == 0){

            ++usedNodes;
            dist[node] = currDist;
            marked[node] = true;
        }

        for(const int &nextNode : adjList[node])
            if(!seen[nextNode]){

                dist[nextNode] = min(dist[nextNode], dist[node] - 1);
                seen[nextNode] = true;
                Queue.push_back(nextNode);
            }
    }

    return usedNodes;
}

int main() {

    fin >> V >> K;
    E = V - 1;

    resizeVectors();
    degree.resize(1 + V, 0);

    for (; E; --E) {

        int from, to;
        fin >> from >> to;

        adjList[from].push_back(to);
        adjList[to].push_back(from);

        ++degree[from]; ++degree[to];
    }

    int ans = 0, usedNodes = 0;
    int low = 1, high = V - 1;

    while (low <= high) {

        int mid = (low + high) / 2;
        int checker = check(mid);

        if (checker <= K) {

            ans = mid;
            usedNodes = checker;
            high = mid - 1;

            for (int node = 1; node <= V; ++node)
                solution[node] = marked[node];
        }
        else low = mid + 1;
    }

    fout << ans << '\n';

    usedNodes = K - usedNodes;
    for (int node = 1; usedNodes; ++node)
        if (!solution[node]) {

            solution[node] = true;
            --usedNodes;
        }

    for (int node = 1; node <= V; ++node)
        if (solution[node])
            fout << node << ' ';
}