#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
long long A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
long long ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec) is >> x;
  return is;
}
class Graph {
  struct edge {
    int from, to, cost;
    edge(int from, int to, int cost) : from(from), to(to), cost(cost) {}
  };

 public:
  int verN;
  int edgeN = 0;
  bool single_source_flag = 0;
  vector<edge> edge_set;
  vector<vector<pair<int, int>>> adj_list;
  vector<vector<int>> dist_all_pairs;
  vector<int> dist_single_source;
  Graph(int verN)
      : verN(verN), adj_list(verN), dist_single_source(verN, (1 << 30)) {}
  void add_directed_edge(int from, int to, int cost = 1) {
    edge_set.push_back(edge(from, to, cost));
    adj_list[from].push_back(make_pair(to, cost));
    edgeN++;
  }
  void add_undirected_edge(int from, int to, int cost = 1) {
    edge_set.push_back(edge(from, to, cost));
    edge_set.push_back(edge(to, from, cost));
    adj_list[from].push_back(make_pair(to, cost));
    adj_list[to].push_back(make_pair(from, cost));
    edgeN += 2;
  }
  bool bellmanford(int start) {
    single_source_flag = 1;
    vector<int> &d = dist_single_source;
    for (int i = 0; i < verN; i++) {
      d[i] = (1 << 30);
    }
    d[start] = 0;
    for (int i = 0; i < verN; i++) {
      for (int j = 0; j < edgeN; j++) {
        edge e = edge_set[j];
        if (d[e.from] != (1 << 30) && d[e.to] > d[e.from] + e.cost) {
          d[e.to] = d[e.from] + e.cost;
          if (i == verN - 1) {
            return false;
          }
        }
      }
    }
    return true;
  }
  void dijkstra(int start) {
    single_source_flag = 1;
    vector<int> &d = dist_single_source;
    d[start] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>,
                   greater<pair<int, int>>>
        pq;
    vector<int> used(verN, 0);
    pq.push(make_pair(0, start));
    while (!pq.empty()) {
      int now = pq.top().second;
      pq.pop();
      used[now] = 1;
      for (auto adj_pair : adj_list[now]) {
        int adj = adj_pair.first;
        int dist = adj_pair.second;
        if (used[adj]) continue;
        if (d[adj] > d[now] + dist) {
          d[adj] = d[now] + dist;
          pq.push(make_pair(d[adj], adj));
        }
      }
    }
  }
  void warshallfloyd() {
    dist_all_pairs.resize(verN, vector<int>(verN, (1 << 30)));
    for (int i = 0; i < verN; i++) {
      for (auto adj_pair : adj_list[i]) {
        int adj = adj_pair.first;
        int dist = adj_pair.second;
        dist_all_pairs[i][adj] = dist;
      }
    }
    for (int k = 0; k < verN; k++) {
      for (int i = 0; i < verN; i++) {
        for (int j = 0; j < verN; j++) {
          dist_all_pairs[i][j] =
              min(dist_all_pairs[i][j],
                  dist_all_pairs[i][k] + dist_all_pairs[k][j]);
        }
      }
    }
  }
  int get_shortest_path(int end) {
    assert(single_source_flag == 1);
    return dist_single_source[end];
  }
  int get_shortest_path(int start, int end) {
    assert(dist_all_pairs.size() != 0);
    return dist_all_pairs[start][end];
  }
};
signed main() {
  int u, v;
  cin >> N >> u >> v;
  u--, v--;
  Graph g(N);
  for (int i = 0; i < (int)(N - 1); i++) {
    cin >> A >> B;
    A--, B--;
    g.add_undirected_edge(A, B);
  }
  vector<int> list;
  vector<int> flag(N, 0);
  queue<int> q;
  q.push(u);
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    flag[now] = 1;
    list.push_back(now);
    if (now == v) {
      continue;
    }
    for (auto adjp : g.adj_list[now]) {
      int adj = adjp.first;
      if (flag[adj]) {
        continue;
      }
      q.push(adj);
    }
  };
  g.dijkstra(v);
  for (int i = 0; i < list.size(); i++) {
    ans = max(int(ans), g.get_shortest_path(list[i]));
  }
  cout << ans - 1 << "\n";
}
