#include <bits/stdc++.h>
using namespace std;
using Int = long long;
using _int = int;
using ll = long long;
using Double = long double;
const Int INF = (1LL << 60) + 1e9;
const Int mod = (1e9) + 7;
const Double EPS = 1e-8;
const Double PI = 6.0 * asin((Double)0.5);
using P = pair<Int, Int>;
template <class T>
T Max(T& a, T b) {
  return a = max(a, b);
}
template <class T>
T Min(T& a, T b) {
  return a = min(a, b);
}
template <class T1, class T2>
ostream& operator<<(ostream& o, pair<T1, T2> p) {
  return o << "(" << p.first << "," << p.second << ")";
}
template <class T1, class T2, class T3>
ostream& operator<<(ostream& o, tuple<T1, T2, T3> t) {
  return o << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
}
template <class T1, class T2>
istream& operator>>(istream& i, pair<T1, T2>& p) {
  return i >> p.first >> p.second;
}
template <class T>
ostream& operator<<(ostream& o, vector<T> a) {
  Int i = 0;
  for (T t : a) o << (i++ ? " " : "") << t;
  return o;
}
template <class T>
istream& operator>>(istream& i, vector<T>& a) {
  for (T& t : a) i >> t;
  return i;
}
class LCA {
 public:
  int LOG_V = 20;
  int V;
  vector<vector<pair<int, int> > > G;
  int root;
  vector<vector<int> > parent;
  vector<int> depth;
  vector<int> D;
  int ok;
  LCA() : V(-1) {}
  LCA(int V, int root = 0)
      : V(V),
        G(V),
        root(root),
        parent(LOG_V, vector<int>(V)),
        depth(V),
        D(V, 0),
        ok(0) {}
  void add_edge(int a, int b, int c = 1) {
    assert(a >= 0 && b >= 0);
    assert(a < V && b < V);
    G[a].push_back(pair<int, int>(b, c));
    G[b].push_back(pair<int, int>(a, c));
  }
  void dfs(int v, int p, int d, int c) {
    assert(v < V);
    parent[0][v] = p;
    depth[v] = d;
    D[v] = c;
    for (auto to : G[v])
      if (to.first != p) dfs(to.first, v, d + 1, c + to.second);
  }
  int getAnc(int v, int n) {
    for (int k = 0; k < LOG_V; k++)
      if ((v != -1) && (n >> k & 1)) v = parent[k][v];
    return v;
  }
  void build() {
    ok = 1;
    dfs(root, -1, 0, 0);
    for (int k = 0; k + 1 < LOG_V; k++)
      for (int v = 0; v < V; v++)
        if (parent[k][v] < 0)
          parent[k + 1][v] = -1;
        else
          parent[k + 1][v] = parent[k][parent[k][v]];
  }
  int lca(int u, int v) {
    assert(ok);
    assert(u >= 0 && v >= 0);
    assert(u < V && v < V);
    if (depth[u] > depth[v]) swap(u, v);
    v = getAnc(v, depth[v] - depth[u]);
    if (u == v) return u;
    for (int k = LOG_V - 1; k >= 0; k--)
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    return parent[0][u];
  }
  int getDis(int u, int v) {
    assert(u >= 0 && v >= 0);
    assert(u < V && v < V);
    return D[u] + D[v] - 2 * D[lca(u, v)];
  }
};
signed main() {
  srand((unsigned)time(NULL));
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);
  int N, u, v;
  cin >> N >> u >> v;
  u--, v--;
  LCA lca(N, v);
  vector<vector<int> > G(N);
  for (int i = 0; i < N - 1; i++) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    lca.add_edge(a, b);
    G[a].push_back(b);
    G[b].push_back(a);
  }
  lca.build();
  int ans = 0;
  for (int i = 0; i < N; i++) {
    int m = lca.lca(u, i);
    int disU = lca.getDis(m, u);
    int disV = lca.getDis(m, v);
    if (disU >= disV) continue;
    Max(ans, lca.getDis(v, i) - 1);
  }
  cout << ans << endl;
  return 0;
}
