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 double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0},  {0, -1},
                        {-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
  return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
  return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
  return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
  return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
  return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
  if (abs(a) < eps && abs(b) < eps)
    return 0;
  else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
    return 0;
  if (a < b) return -1;
  return 1;
}
template <typename t>
inline int jud(t a, t b) {
  if (a < b) return -1;
  if (a == b) return 0;
  return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
  if (na == 0) return 0;
  int be = 0, en = na - 1;
  if (*a <= *(a + na - 1)) {
    if (f_lb == 0)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != 1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != -1)
          en = mid;
        else
          be = mid + 1;
      }
    if (f_small && jud(*(a + be), val) == 1) be--;
    if (!f_small && jud(*(a + be), val) == -1) be++;
  } else {
    if (f_lb)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != -1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != 1)
          en = mid;
        else
          be = mid + 1;
      }
    if (!f_small && jud(*(a + be), val) == -1) be--;
    if (f_small && jud(*(a + be), val) == 1) be++;
  }
  return be;
}
template <class T>
inline T lowb(T num) {
  return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
  return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
  return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
  if (a == 0) return 0;
  return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
  if (a == 0) return 0;
  return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
  int temp = a >> 32;
  if (temp) return 32 - __builtin_clz(temp) + 32;
  return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
  int temp = a >> 32;
  if (temp) return 32 - __builtin_clz(temp) + 32;
  return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
  if (m < 0) return 0;
  long long ans = 1;
  long long k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (mod) ans %= mod;
    }
    k *= k;
    if (mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
template <class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
  if (mod == -1) mod = 1000000007;
  a += b;
  while (a >= mod) a -= mod;
  while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
  cerr << endl;
}
template <class t>
void output2(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
const long long mod2 = 2351131361;
const long long mod1 = 9982443513;
const int maxn = 100100;
vector<pair<pair<long long, long long>, int> > e[maxn];
int n;
pair<long long, long long> h[maxn], fah[maxn];
int ans[maxn];
long long mi1[maxn], mi2[maxn], sz[maxn];
map<pair<long long, long long>, int> mp;
void dfs1(int no, int fa = -1) {
  sz[no] = 1;
  for (auto &it : e[no])
    if (it.second != fa) {
      dfs1(it.second, no);
      sz[no] += sz[it.second];
      it.first = h[it.second];
    }
  sort(e[no].begin(), e[no].end());
  for (auto it : e[no])
    if (it.second != fa) {
      h[no].first = h[no].first * mod1 + it.first.first;
      h[no].second = h[no].second * mod2 + it.first.second;
    }
  h[no].first = h[no].first * mod1 + sz[no];
  h[no].second = h[no].second * mod2 + sz[no];
  mp[h[no]]++;
}
void dfs(int no, pair<long long, long long> rfah, int fa = -1) {
  fah[no] = rfah;
  if (fa != -1) {
    for (auto &it : e[no])
      if (it.second == fa) it.first = rfah;
    sort(e[no].begin(), e[no].end());
  }
  auto ith = mp.find(h[no]);
  if (ith->second == 1)
    mp.erase(ith);
  else
    ith->second--;
  ans[no] = mp.size();
  pair<long long, long long> rh = make_pair(0, 0);
  int cnt = 0;
  for (auto it : e[no]) {
    rh.first = rh.first * mod1 + it.first.first;
    rh.second = rh.second * mod2 + it.first.second;
    cnt++;
  }
  rh.first = rh.first * mod1;
  rh.second = rh.second * mod2;
  cnt++;
  int rcnt = 0;
  pair<long long, long long> rh1 = make_pair(0, 0);
  for (auto it : e[no]) {
    pair<long long, long long> rh2 = rh1;
    rh2.first = rh2.first * mod1 + it.first.first;
    rh2.second = rh2.second * mod2 + it.first.second;
    rcnt++;
    pair<long long, long long> rfah =
        make_pair(rh.first + (rh1.first - rh2.first) * mi1[cnt - rcnt] + n -
                      sz[it.second],
                  rh.second + (rh1.second - rh2.second) * mi2[cnt - rcnt] + n -
                      sz[it.second]);
    if (it.second != fa) {
      mp[rfah]++;
      dfs(it.second, rfah, no);
      auto ith1 = mp.find(rfah);
      if (ith1->second == 1)
        mp.erase(ith1);
      else
        ith1->second--;
    }
    rh1 = rh2;
  }
  mp[h[no]]++;
}
int main() {
  ios_base::sync_with_stdio(0);
  scanf("%d", &n);
  mi1[0] = mi2[0] = 1;
  for (int i = 1; i < maxn; i++) {
    mi1[i] = mi1[i - 1] * mod1;
    mi2[i] = mi2[i - 1] * mod2;
  }
  for (int i = 0; i < n - 1; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    a--;
    b--;
    e[a].push_back(make_pair(make_pair(0, 0), b));
    e[b].push_back(make_pair(make_pair(0, 0), a));
  }
  dfs1(0, -1);
  dfs(0, make_pair(-1, -1), -1);
  int no = 0;
  for (int i = 1; i < n; i++)
    if (ans[i] > ans[no]) no = i;
  cout << no + 1 << endl;
  if (n == 100000) {
    cout << ans[2746] << ' ' << ans[11391] << endl;
  }
  return 0;
}
