#include <bits/stdc++.h>
template <class T> using Vec = std::vector<T>;
template <class F> struct RecLambda : private F {
explicit RecLambda(F&& f) : F(std::forward<F>(f)) {}
template <class... Args> decltype(auto) operator() (Args&&... args) const {
return F::operator()(*this, std::forward<Args>(args)...);
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int N, T, M;
std::cin >> N >> T >> M;
T -= 1;
M -= 1;
Vec<Vec<int>> graph(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
std::cin >> a >> b;
a -= 1;
b -= 1;
graph[a].push_back(b);
graph[b].push_back(a);
}
Vec<int> parent(N, -1);
RecLambda([&](auto&& dfs, const int u) -> void {
for (const int v : graph[u]) {
if (parent[u] != v) {
parent[v] = u;
dfs(v);
}
}
})(T);
Vec<int> path;
Vec<char> on_path(N);
for (int u = M; u != T; u = parent[u]) {
path.push_back(u);
on_path[u] = true;
}
Vec<int> dp(N, -1);
const auto down = RecLambda([&](auto&& dfs, const int u) -> int {
if (dp[u] != -1) {
return dp[u];
}
Vec<int> cand;
for (const int v : graph[u]) {
if (v != parent[u] and !on_path[v]) {
cand.push_back(dfs(v));
}
}
std::sort(cand.rbegin(), cand.rend());
if (cand.size() <= 1) {
return dp[u] = (int) cand.size();
}
return dp[u] = cand[1] + (int) cand.size();
});
Vec<int> cut(N);
RecLambda([&](auto&& dfs, const int u) -> void {
for (const int v : graph[u]) {
if (parent[u] != v) {
cut[v] += cut[u];
if (u != T) {
cut[v] += (int) graph[u].size() - 2;
}
dfs(v);
}
}
})(T);
int ok = N, ng = (int) path.size();
while (ok - ng > 1) {
const int md = (ok + ng) / 2;
([&] {
for (int i = 0; i < (int) path.size(); ++i) {
const int u = path[i];
if (down(u) + cut[u] + i > md) {
return false;
}
}
return true;
}() ? ok : ng) = md;
}
std::cout << ok << '\n';
return 0;
}
