///O(n**2).
#include <bits/stdc++.h>
#define aaa system("read -r -p \"Press enter to continue...\" key");
#define dbg(x) std::cerr<<(#x)<<": "<<(x)<<'\n',aaa
#define dbga(x,n) std::cerr<<(#x)<<"[]: ";for(int _=0;_<n;_++)std::cerr<<x[_]<<' ';std::cerr<<'\n',aaa
#define dbgs(x) std::cerr<<(#x)<<"[stl]: ";for(auto _:x)std::cerr<<_<<' ';std::cerr<<'\n',aaa
#define dbgp(x) std::cerr<<(#x)<<": "<<x.first<<' '<<x.second<<'\n',aaa
#define dbgsp(x) std::cerr<<(#x)<<"[stl pair]:\n";for(auto _:x)std::cerr<<_.first<<' '<<_.second<<'\n';aaa
 
const int maxn = 100'000, inf = (1 << 30) - 1;
std::vector<int> g[maxn];
int ans_bfs_dfs = inf, ans_dfs_bfs = inf;
int df_index = 0;
int df_poz[maxn];

///bfs din z. tatal lui z e t. intoarce poz lui k in bfs(z).
int bfs_from(int n, int k, int z, int t) {
    std::vector<int> qu_index(n, inf);
 
    std::queue<int> qu;
    qu.push(z);
    qu_index[z] = 1;
 
    int qi = 2;
    while (!qu.empty()) {
        int nod = qu.front(); qu.pop();
        for (int nn: g[nod]) {
            if (nn != t && qu_index[nn] == inf) {
                qu.push(nn);
                qu_index[nn] = qi++;
                if (nn == k) return qu_index[k];
            }
        }
    }
 
    return qu_index[k];
}

std::vector<int> df_order;
void dfs_from(int nod) {
    df_order.push_back(nod);
    for (int nn: g[nod]) if (df_poz[nn] > df_poz[nod]) dfs_from(nn);
}
 
void dfs_bfs(int n, int k, int nod, int t) {
    df_poz[nod] = df_index++;
 
    ans_dfs_bfs = std::min(ans_dfs_bfs, df_index + bfs_from(n, k, nod, t) - 1);
 
    for (int nn: g[nod]) {
        if (nn != t) {
            dfs_bfs(n, k, nn, nod);
        }
    }
}
 
void bfs_dfs(int n, int k) {
    std::queue<int> qu;
    std::vector<int> viz(n);
 
    qu.push(0);
    viz[0] = 1;
    int bf_index = 2;
    while (!qu.empty()) {
        int nod = qu.front(); qu.pop();
 
        df_order.clear();
        dfs_from(nod);
        int ind_k = std::find(df_order.begin(), df_order.end(), k) - df_order.begin();
        if (ind_k < (int)df_order.size()) {
            ans_bfs_dfs = std::min(ans_bfs_dfs, viz[nod] + ind_k);
        }
 
        for (int nn: g[nod]) {
            if (viz[nn] == 0) {
                qu.push(nn);
                viz[nn] = bf_index++;
            }
        }
    }
}
 
int main() {
    std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout.tie(0);
    
    int n, k; std::cin >> n >> k;
    k--;
 
    for (int i = 0; i < n-1; i++) {
        int a, b; std::cin >> a >> b;
        a--; b--;
        g[a].push_back(b);
        g[b].push_back(a);
    }
 
    dfs_bfs(n, k, 0, -1);
    bfs_dfs(n, k);
 
    std::cout << ans_bfs_dfs << '\n' << ans_dfs_bfs << '\n';
 
    return 0;
}