#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T pow_mod(T a, U b, int mod) {
  T r = 1;
  for (; b > 0; b >>= 1) {
    if (b & 1) r = (long long)r * a % mod;
    a = (long long)a * a % mod;
  }
  return r;
}
namespace multihash {
const int D = 2, N = 25;
array<int, D> B[N], iB[N], M, Z;
array<int, D> operator+(array<int, D> lhs, const array<int, D> &rhs) {
  for (int i = 0; i < D; ++i) {
    lhs[i] += rhs[i];
    if (lhs[i] >= M[i]) lhs[i] -= M[i];
  }
  return lhs;
}
array<int, D> operator-(array<int, D> lhs, const array<int, D> &rhs) {
  for (int i = 0; i < D; ++i) {
    lhs[i] -= rhs[i];
    if (lhs[i] < 0) lhs[i] += M[i];
  }
  return lhs;
}
array<int, D> operator*(array<int, D> lhs, const array<int, D> &rhs) {
  for (int i = 0; i < D; ++i) lhs[i] = (long long)lhs[i] * rhs[i] % M[i];
  return lhs;
}
array<int, D> pow(array<int, D> lhs, long long b) {
  array<int, D> x;
  x.fill(1);
  for (; b > 0; b >>= 1) {
    if (b & 1) x = x * lhs;
    lhs = lhs * lhs;
  }
  return x;
}
array<int, D> inv(array<int, D> lhs) {
  for (int i = 0; i < D; ++i) lhs[i] = pow_mod(lhs[i], M[i] - 2, M[i]);
  return lhs;
}
array<int, D> to_mhash(int x) {
  array<int, D> m;
  m.fill(x);
  for (int i = 0; i < D; ++i) m[i] %= M[i];
  return m;
}
void init(const array<int, D> &b, const array<int, D> &m) {
  M = m, B[1] = b, iB[1] = inv(b), Z.fill(0), B[0].fill(1), iB[0].fill(1);
  for (int i = 2; i < N; ++i) {
    B[i] = B[i - 1] * B[1];
    iB[i] = iB[i - 1] * iB[1];
  }
}
}  // namespace multihash
namespace merkle_tree {
using namespace multihash;
int solve(const vector<vector<int>> &adj) {
  int n = adj.size();
  vector<pair<int, bool>> d(n);
  vector<int> mask(n);
  vector<array<int, D>> h(n);
  for (auto &i : mask) i = rand();
  auto f = [&](int u, int p) {
    h[u].fill(1);
    for (auto v : adj[u])
      if (v != p) h[u] = h[u] * (h[v] + to_mhash(mask[d[u].first]));
  };
  auto g = [&](int u, int p) {
    d[u].first = 0, d[u].second = false;
    for (auto v : adj[u])
      if (v != p) {
        if (d[v].first + 1 > d[u].first)
          d[u].first = d[v].first + 1, d[u].second = true;
        else if (d[v].first + 1 == d[u].first)
          d[u].second = false;
      }
  };
  function<void(int, int)> dfs1 = [&](int u, int p) {
    for (auto v : adj[u])
      if (v != p) dfs1(v, u);
    g(u, p);
    f(u, p);
  };
  dfs1(0, -1);
  auto z = [&](array<int, D> x) { return (long long)x[0] << 32 | x[1]; };
  map<long long, int> mp;
  for (int u = 0; u < n; ++u) ++mp[z(h[u])];
  int cnt = mp.size(), best = 0, node;
  auto update = [&](array<int, D> u, int c) {
    long long x = z(u);
    cnt -= mp[x] > 0;
    mp[x] += c;
    cnt += mp[x] > 0;
  };
  function<void(int, int)> dfs2 = [&](int u, int p) {
    if (cnt > best) best = cnt, node = u;
    for (auto v : adj[u])
      if (v != p) {
        update(h[v], -1);
        update(h[u], -1);
        auto du = d[u];
        auto dv = d[v];
        array<int, D> hu = h[u];
        array<int, D> hv = h[v];
        if (d[u].first == d[v].first + 1 && d[u].second)
          g(u, v), f(u, v);
        else
          h[u] = h[u] * inv(h[v] + to_mhash(mask[d[u].first]));
        if (d[u].first + 1 > d[v].first)
          d[v].first = d[u].first + 1, d[v].second = true;
        else if (d[u].first + 1 == d[v].first)
          d[v].second = false;
        f(v, -1);
        update(h[v], +1);
        update(h[u], +1);
        dfs2(v, u);
        update(h[v], -1);
        update(h[u], -1);
        d[u] = du;
        d[v] = dv;
        h[u] = hu;
        h[v] = hv;
        update(h[v], +1);
        update(h[u], +1);
      }
  };
  dfs2(0, -1);
  return node;
}
}  // namespace merkle_tree
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  multihash::init({13, 47}, {(int)1e9 + 7, (int)1e9 + 9});
  int n;
  cin >> n;
  vector<vector<int>> adj(n);
  for (int i = 1, u, v; i < n; ++i) {
    cin >> u >> v;
    --u, --v;
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  cout << merkle_tree::solve(adj) + 1 << "\n";
  return 0;
}
