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;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%lld", &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
  return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%lld", _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
  SP(_x);
  if (sizeof...(_tail)) putchar(' ');
  PL(_tail...);
}
const int maxn = 1e5 + 5;
const int MOD = 1e9 + 9;
struct T {
  int a, b;
  T() : a(0), b(0) {}
  T(int _a, int _b) : a(_a), b(_b) {}
  int f(const int &x) const { return x < MOD ? x : x - MOD; }
  T operator+(const T &t) const { return T(f(a + t.a), f(b + t.b)); }
  T operator-(const T &t) const {
    return T(f(a + MOD - t.a), f(b + MOD - t.b));
  }
  T operator*(const T &t) const {
    return T(1LL * a * t.a % MOD, 1LL * b * t.b % MOD);
  }
  bool operator<(const T &t) const { return tie(a, b) < tie(t.a, t.b); }
  bool operator==(const T &t) const { return tie(a, b) == tie(t.a, t.b); }
} bas{maxn * 2 + 7, maxn * 2 + 11}, bp[maxn];
int n;
vector<int> edge[maxn];
void read() {
  RI(n);
  for (int i = 0; i < int(n - 1); i++) {
    int a, b;
    RI(a, b);
    edge[a].push_back(b);
    edge[b].push_back(a);
  }
}
struct H {
  map<T, int> mp;
  T id(const T &i) {
    if (!mp.count(i)) {
      int siz = mp.size() + 1;
      mp[i] = siz;
      return T(siz, siz);
    }
    int res = mp[i];
    return T(res, res);
  }
} h;
int dfs1(int u, int p, int &root, int &dp) {
  int siz = 1, my = 0;
  for (int v : edge[u])
    if (v != p) {
      int sub = dfs1(v, u, root, dp);
      siz += sub;
      my = max(my, sub);
    }
  my = max(my, n - siz);
  if (my < dp) dp = my, root = u;
  return siz;
}
int siz[maxn];
int dfs2(int u, int p) {
  siz[u] = 1;
  for (int v : edge[u])
    if (v != p) siz[u] += dfs2(v, u);
  return siz[u];
}
T subh[maxn];
void dfs3(int u, int p) {
  if (siz[u] == 1) {
    subh[u] = h.id(T(0, 0));
    return;
  }
  for (int v : edge[u])
    if (v != p) dfs3(v, u);
  sort((edge[u]).begin(), (edge[u]).end(), [&](int a, int b) {
    return tie(siz[a], subh[a]) < tie(siz[b], subh[b]);
  });
  assert(siz[u] == n || edge[u].back() == p);
  T cur(0, 0);
  for (int v : edge[u])
    if (v != p) cur = cur * bas + subh[v];
  cur = h.id(cur);
  subh[u] = cur;
}
T parh[maxn];
vector<T> kh[maxn];
void dfs4(int u, int p, const T &w) {
  if (siz[u] == n) {
    const int z = ((int)(edge[u]).size());
    kh[u].resize(z + 1);
    kh[u][0] = T(0, 0);
    for (int i = (1); i <= int(z); i++)
      kh[u][i] = kh[u][i - 1] * bas + subh[edge[u][i - 1]];
    for (int i = (1); i <= int(z); i++) {
      T cur = kh[u].back(), pw = bp[z - i];
      cur = cur - kh[u][i] * pw;
      cur = cur + kh[u][i - 1] * pw;
      cur = h.id(cur);
      dfs4(edge[u][i - 1], u, cur);
    }
    return;
  }
  assert(siz[u] == n || edge[u].back() == p);
  parh[u] = w;
  const int z = ((int)(edge[u]).size()) - 1;
  kh[u].resize(z + 1);
  kh[u][0] = T(0, 0);
  for (int i = (1); i <= int(z); i++)
    kh[u][i] = kh[u][i - 1] * bas + subh[edge[u][i - 1]];
  for (int i = (1); i <= int(z); i++) {
    T cur = kh[u].back(), pw = bp[z - i];
    cur = cur - kh[u][i] * pw;
    cur = cur + kh[u][i - 1] * pw;
    cur = cur * bas + w;
    cur = h.id(cur);
    dfs4(edge[u][i - 1], u, cur);
  }
}
void build() {
  bp[0] = T(1, 1);
  for (int i = (1); i <= int(maxn - 1); i++) bp[i] = bp[i - 1] * bas;
  int root = -1;
  {
    int dp = maxn;
    dfs1(1, 0, root, dp);
  }
  assert(root != -1);
  dfs2(root, 0);
  dfs3(root, 0);
  dfs4(root, 0, T(0, 0));
}
struct Q {
  map<T, int> cnt;
  void add(const T &i) { cnt[i]++; }
  void del(const T &i) {
    if (--cnt[i] == 0) cnt.erase(i);
  }
  int size() const { return ((int)(cnt).size()); }
} q;
void dfs5(int u, int p, int &ans, int &dp) {
  ;
  if (siz[u] == n) {
    const int z = ((int)(edge[u]).size());
    for (int i = (1); i <= int(z); i++) {
      const int v = edge[u][i - 1];
      q.del(subh[v]);
      q.add(parh[v]);
      dfs5(v, u, ans, dp);
      q.add(subh[v]);
      q.del(parh[v]);
    }
    return;
  }
  if (((int)(q).size()) > dp) dp = ((int)(q).size()), ans = u;
  const int z = ((int)(edge[u]).size()) - 1;
  for (int i = (1); i <= int(z); i++) {
    const int v = edge[u][i - 1];
    q.del(subh[v]);
    q.add(parh[v]);
    dfs5(v, u, ans, dp);
    q.add(subh[v]);
    q.del(parh[v]);
  }
}
void sol() {
  int root = max_element(siz + 1, siz + n + 1) - siz;
  for (int i = (1); i <= int(n); i++)
    if (i != root) q.add(subh[i]);
  int ans = root, dp = ((int)(q).size());
  dfs5(root, 0, ans, dp);
  PL(ans);
}
int main() {
  read();
  build();
  sol();
  return 0;
}
