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;

using LL = long long;
template<typename T> using V = vector<T>; 
template<typename T, typename S> using P = pair<T, S>; 
template<class T> using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
using LD = long double;

#define ALL(v) v.begin(), v.end()
#define en(v) *(--v.end())
#define endl '\n'
#define SYNC ios_base::sync_with_stdio(false); cin.tie(NULL); cerr.tie(NULL);
#define REP(i, n) for(int i = 0; i < (int)n ;i++)
#define REPN(i, n) for(int i = 1; i <= (int)n ; i++)
#define her 	cerr << "here\n" 
#define pp push_back
#define fi first 
#define se second
#define un(x) x.erase(unique(ALL(x)), x.end())

template<typename T, typename S> void check(T & a, S & b) { if (a >= b) { a %= b; } }
template<typename T>T gcd(T u, T v) { if (u == v)return u; if (u == 0)return v; if (v == 0)return u; if (~u & 1) { if (v & 1) return gcd(u >> 1, v); else return gcd(u >> 1, v >> 1) << 1; }if (~v & 1)return gcd(u, v >> 1); if (u > v)return gcd((u - v) >> 1, v); return gcd((v - u) >> 1, u); }

template<class TH> void _dbg(const char *sdbg, TH h){cerr<<sdbg<<"="<<h<<"\n";}
template<class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
	while(*sdbg!=','){cerr<<*sdbg++;} cerr<<"="<<h<<","; _dbg(sdbg+1, a...);
}

#ifdef aishwarya_tandon_is_the_best
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) (__VA_ARGS__)
#define cerr if(0)cout
#endif

template<class T> ostream &operator<<(ostream &os, vector<T> V) {
	os<<"[ ";for(auto &vv:V)os<<vv<<", "[&vv == &V.back()]; return os << "]";
}

template<class L, class R> ostream &operator<<(ostream &os, pair<L,R> P) {
	return os << "(" << P.fi << "," << P.se << ")";
}

using ull = unsigned long long;
using Hash = P<ull, ull>;
const int N = (int)1e5 + 10;
const ull P1 = (int)1e9 + 7,
		  P2 = (int)1e9 + 9,
		  base1 = 259322957,
		  base2 = 13118891;

ull save1[N], save2[N], inv1[N], inv2[N];
Hash h1[N], h2[N];
V<int> g[N];
map<Hash, int> Map;
int cur_ans, cur_idx, total_ans;

void add(Hash & x, Hash y, Hash z) {
	x.fi = (y.fi * base1 + z.fi) % P1;
	x.se = (y.se * base2 + z.se) % P2;
}

Hash sub(Hash x, Hash y) {
	Hash ans = {(x.fi - y.fi + P1) % P1, (x.se - y.se + P2) % P2};
	return ans;
}

void inc(Hash val) {
	if(Map[val] == 0) 
		total_ans ++;
	Map[val]++;
}

void dec(Hash val) {
	if(Map[val] == 1)
		total_ans--;
	Map[val]--;
}

void pre() {
	save1[0] = save2[0] = 1;
	inv1[0] = inv2[0] = 1;
	inv1[1] = 605858635;
	inv2[1] = 604553047;
	for(int i = 1; i < N; i ++) {
		save1[i] = (save1[i - 1] * base1) % P1;
		save2[i] = (save2[i - 1] * base2) % P2;
		if(i > 1) {
			inv1[i] = (inv1[i - 1] * inv1[1]) % P1;
			inv2[i] = (inv2[i - 1] * inv2[1]) % P2;
		}
	}
}

void dfs(int u, int p) {
	h1[u] = {1, 1};
	for(int & i : g[u]) {
		if(i != p) {
			dfs(i, u);
		}
	}
	sort(ALL(g[u]), [&](int a, int b) { return h1[a] < h1[b]; });
	for(int & i : g[u]) {
		if(i != p) {
			add(h1[u], h1[u], h1[i]);
		}
	}
	inc(h1[u]);
	debug(u, h1[u]);
}

void _dfs(int u, int p, Hash par_last_hash) {
	dec(h1[u]);
	V<Hash> prefix{{1, 1}};
	V<P<Hash, int>> hashes;
	for(int & i : g[u]) {
		if(i == p && p + 1) hashes.pp({par_last_hash, i});
		else hashes.pp({h1[i], i});
	}
	// debug(hashes);
	sort(ALL(hashes));
	Hash new_hash = {1, 1};
	int K = (int)hashes.size();
	// debug(u, K);

	for(int i = 0; i < K; i ++) {
		prefix.pp({0, 0});
		add(prefix[i + 1], prefix[i], hashes[i].fi);
		debug(u, hashes[i].se, hashes[i].fi, h1[hashes[i].se], prefix[i + 1]);
	}new_hash = prefix.back();

	inc(new_hash);
	if(total_ans > cur_ans) {
		cur_ans = total_ans;
		cur_idx = u;
	}
	dec(new_hash);
	debug(u, K, new_hash);
	for(int i = 0; i < K; i ++) {
		if(hashes[i].se == p) continue;
		Hash new_children_hash;
		Hash Left = prefix[i];
		Hash Right = sub(new_hash, {(prefix[i + 1].fi * save1[K - i - 1]) % P1,
									(prefix[i + 1].se * save2[K - i - 1]) % P2});
		debug(new_hash, prefix[i], prefix[i + 1], Left, Right);
		new_children_hash = {(Left.fi + Right.fi) % P1, (Right.se + Left.se * save2[i]) % P2};
		debug(new_children_hash);
		inc(new_children_hash);
		_dfs(hashes[i].se, u, new_children_hash);
		dec(new_children_hash);
	}

	inc(h1[u]);
	return;
}

int32_t main(){ SYNC;
	pre();
	int n;
	cin >> n;
	REP(i, n - 1) {
		int u, v;
		cin >> u >> v;
		g[u].pp(v);
		g[v].pp(u);
	}
	dfs(1, 0);
	_dfs(1, 0, {0, 0});
	debug(cur_ans);
	cout << cur_idx << endl;
	cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms" << '\n';
	return 0; 
}