10
6 8
3 10
1 9
6 1
8 2
5 7
3 6
10 4
3 5
 1
 5
1 2
2 3
3 4
4 5
 7
2 3
2 6
1 2
3 7
6 5
3 4
 10
8 4
8 10
8 1
8 2
5 9
5 3
5 7
8 5
5 6
 10
8 6
3 4
10 9
7 10
1 3
4 2
6 1
5 8
9 5
 10
1 10
6 9
5 4
1 3
1 2
3 8
6 7
8 6
1 5
 20
13 4
7 6
9 13
9 2
9 16
4 18
16 5
11 15
16 14
13 12
13 8
16 17
7 1
9 19
17 3
15 20
1 11
2 7
5 10
 3
1 2
1 3
 50
18 47
18 12
42 16
21 44
43 39
20 27
25 1
11 29
9 24
19 42
3 34
16 38
14 48
23 41
8 43
29 2
40 4
45 36
43 9
49 3
41 17
41 15
35 49
43 20
5 32
34 46
8 21
43 45
29 40
39 26
27 33
24 50
38 7
39 19
43 31
24 10
3 14
39 22
43 23
47 13
20 11
25 8
16 30
44 18
19 37
39 5
49 28
25 35
46 6
 15
11 2
5 13
9 4
5 7
11 5
13 14
2 10
3 11
7 1
7 6
10 15
9 12
2 9
10 8
 31
15 2
23 19
11 4
26 6
1 20
14 11
19 13
26 12
12 27
20 14
22 21
4 16
10 18
5 23
4 31
12 8
2 17
19 30
14 26
2 28
22 7
23 9
20 5
5 15
9 29
15 10
6 25
6 24
9 3
11 22
 63
34 40
43 62
33 43
49 6
17 47
26 13
35 15
40 16
17 44
37 34
18 55
57 10
16 14
39 56
36 5
4 33
4 59
54 24
37 45
21 31
57 2
19 8
43 41
49 48
15 19
35 4
15 63
30 50
11 30
59 18
20 46
18 1
33 17
31 22
40 54
63 49
29 25
46 9
16 3
42 23
59 7
54 53
42 38
8 60
8 58
7 51
36 28
63 36
21 57
25 37
45 20
25 35
19 26
20 42
30 32
11 39
7 12
31 52
45 21
26 27
34 11
46 61

9
 1
 1
 1
 1
 2
 10
 18
 2
 13
 1
 3
 1

#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 50;
const int mods[4] = {(int)1e9 + 7, (int)1e9 + 9, (int)1e9 + 21, (int)1e9 + 33};
const int mod = 998244353;
int p = 10;
long long pw[4][N];
struct hs {
  long long val[2];
  hs() { fill(val, val + 2, 0); }
  hs(long long a, long long b, long long c, long long d) {
    val[0] = a, val[1] = b;
  }
  bool operator<(const hs &other) const {
    for (int i = 0; i < 2; i++)
      if (val[i] != other.val[i]) return val[i] < other.val[i];
    return false;
  }
  bool operator==(const hs &other) const {
    for (int i = 0; i < 2; i++)
      if (val[i] != other.val[i]) return false;
    return true;
  }
  hs operator+(const hs &other) const {
    hs res;
    for (int i = 0; i < 2; i++) res.val[i] = (val[i] + other.val[i]) % mods[i];
    return res;
  }
  hs operator-(const hs &other) const {
    hs res;
    for (int i = 0; i < 2; i++)
      res.val[i] = (val[i] - other.val[i] + mods[i]) % mods[i];
    return res;
  }
  hs operator^(const int pwi) const {
    hs res;
    for (int i = 0; i < 2; i++) {
      res.val[i] = (val[i] * pw[i][pwi]) % mods[i];
    }
    return res;
  }
  void add(int x, int pwi) {
    for (int i = 0; i < 2; i++) {
      val[i] = (val[i] + x * pw[i][pwi]) % mods[i];
      if (val[i] < 0) val[i] += mods[i];
    }
  }
};
int get_count(vector<pair<hs, int> > &v, pair<hs, int> &h) {
  return (int)(upper_bound(v.begin(), v.end(), h) -
               lower_bound(v.begin(), v.end(), h));
}
int fres = 0, id;
struct Graph {
  int n;
  vector<int> G[N];
  pair<hs, int> dp[N];
  void init() {
    fres = 0;
    id = -1;
    tcnt = 0;
    mp.clear();
    cin >> n;
    for (int i = 0; i < n; i++) G[i].clear();
    for (int i = 0; i < n - 1; i++) {
      int a, b;
      cin >> a >> b;
      a--, b--;
      G[a].push_back(b);
      G[b].push_back(a);
    }
  }
  pair<hs, int> wrap(pair<hs, int> pl) {
    pl.first.add(1, pl.second);
    pl.first = pl.first ^ 1;
    pl.second += 2;
    return pl;
  }
  pair<hs, int> merge(pair<hs, int> p1, pair<hs, int> p2) {
    return pair<hs, int>((p1.first ^ p2.second) + p2.first,
                         p1.second + p2.second);
  }
  vector<pair<hs, int> > pls_all[N], psum_all[N], ssum_all[N];
  pair<hs, int> dfs(int v, int p) {
    vector<pair<hs, int> > &pls = pls_all[v];
    pls.clear();
    for (int i = 0; i < G[v].size(); i++) {
      int nxt = G[v][i];
      if (nxt != p) {
        pls.push_back(dfs(nxt, v));
      }
    }
    sort(pls.begin(), pls.end());
    pair<hs, int> res;
    for (pair<hs, int> pl : pls) res = merge(res, pl);
    return dp[v] = wrap(res);
  }
  pair<hs, int> get_except(vector<pair<hs, int> > &psum,
                           vector<pair<hs, int> > &ssum, int i) {
    pair<hs, int> res;
    if (i > 0) res = merge(res, psum[i - 1]);
    if (i + 1 < ssum.size()) res = merge(res, ssum[i + 1]);
    return res;
  }
  int tcnt;
  map<pair<hs, int>, int> mp;
  void add(pair<hs, int> &h, int val) {
    int &cnt = mp[h];
    tcnt -= cnt > 0;
    cnt += val;
    tcnt += cnt > 0;
  }
  void reroot(int v, int p, pair<hs, int> up_hs) {
    vector<pair<hs, int> > &pls = pls_all[v];
    pls.clear();
    vector<pair<hs, int> > &psum = psum_all[v];
    psum.clear();
    vector<pair<hs, int> > &ssum = ssum_all[v];
    ssum.clear();
    for (int nxt : G[v]) {
      if (nxt != p) pls.push_back(dp[nxt]);
    }
    if (p != -1) pls.push_back(up_hs);
    sort(pls.begin(), pls.end());
    psum.resize(pls.size());
    ssum.resize(pls.size());
    psum[0] = pls[0];
    for (int i = 1; i < pls.size(); i++) psum[i] = merge(psum[i - 1], pls[i]);
    ssum.back() = pls.back();
    for (int i = (int)pls.size() - 2; i >= 0; i--)
      ssum[i] = merge(pls[i], ssum[i + 1]);
    add(dp[v], -1);
    pair<hs, int> cur_res = wrap(ssum[0]);
    add(cur_res, 1);
    if (tcnt > fres) {
      fres = tcnt;
      id = v;
    }
    add(cur_res, -1);
    for (int nxt : G[v]) {
      if (nxt == p) continue;
      auto fir = lower_bound(pls.begin(), pls.end(), dp[nxt]) - pls.begin();
      pair<hs, int> new_hs = wrap(get_except(psum, ssum, fir));
      add(new_hs, 1);
      reroot(nxt, v, new_hs);
      add(new_hs, -1);
    }
    add(dp[v], 1);
  }
} g;
void solve() {
  g.init();
  if (g.n == 1) {
    cout << "1"
         << "\n";
    return;
  }
  g.dfs(0, -1);
  for (int i = 0; i < g.n; i++) g.add(g.dp[i], 1);
  g.reroot(0, -1, pair<hs, int>());
  cout << id + 1 << "\n";
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  for (int t = 0; t < 4; t++) {
    pw[t][0] = 1;
    for (int i = 1; i < N; i++) pw[t][i] = pw[t][i - 1] * p % mods[t];
  }
  solve();
}
