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

//Shubham Vijayvargiya

#pragma GCC optimize("O3")
#pragma comment(linker, "/STACK:66777216")
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define pb push_back
#define mp make_pair
#define eb emplace_back
#define F first
#define S second
#define sz(a) (int)(a.size())
#define set(a,b) memset(a,b,sizeof(a))
#define let(x,a) __typeof(a) x(a)
#define rep(i, begin, end) for (ll i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define all(v) (v).begin(),(v).end()
#define sll(x) { scanf("%lld",&x); }
#define si(x) { scanf("%d",&x); }
#define slf(x) { scanf("%lf",&x); }
#define pll(x) { printf("%lld\n",x); }
#define pi(x) { printf("%d\n",x); }
#define tcases() long long testcases; cin>>testcases ; while(testcases--)

#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " = " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " = " << arg1<<" | ";__f(comma+1, args...);
}

#else
#define trace(...)
#endif

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

typedef long long ll;
typedef long double ld;
typedef pair<long long,long long> pll;
typedef vector<long long> vll;
typedef vector<pll> vpll;
typedef vector<vll> vvll;

const ll mod=1000000007;
const ll mod2=1000000993;
const ll mod3=1000000223;
//-----------------------------------------------------------------------------------------------------------------------------------------------//
#define N 100009
ll P=137;
vll g[100009];
ll ans1,ans2,pw[N],pw2[N],pw3[N],sz[N];
pair<ll,pll> hs[100009];
map<pair<ll,pll>,int> ret;

ll powmod(ll a,ll b,ll mod){
	ll res=1;
	while(b){
		if(b&1)
			res=(res*a)%mod;
		b>>=1;
		a=(a*a)%mod;
	}
	return res;
}

void dfs(ll u,ll p){
//	trace(u,p);
	ll res=1;
	ll res2=1;
	ll res3=1;
	sz[u]=1;
	if(g[u].empty()){
		hs[u].F=hs[u].S.F=hs[u].S.S=1;
		ret[hs[u]]++;
		return ;
	}
	for(auto v:g[u]){
		if(v==p)
			continue;
		dfs(v,u);
		sz[u]+=sz[v];
		res=(res*((pw[sz[v]]+hs[v].F)%mod))%mod;
		res2=(res2*((pw2[sz[v]]+hs[v].S.F)%mod2))%mod2;
		res3=(res3*((pw3[sz[v]]+hs[v].S.S)%mod3))%mod3;
	}
/*	res=(res+P)%mod;
	res2=(res2+P)%mod2;
	res2=(res3+P)%mod3;*/

	hs[u].F=res;
	hs[u].S.F=res2;
	hs[u].S.S=res3;
	ret[hs[u]]++;
}

void dfs1(ll u,ll p){
	if(sz(ret)>ans1){
		ans2=u;
		ans1=sz(ret);
	}
	for(auto v:g[u]){
		if(v==p)
			continue;
//		if(u==54019 or v==54019)
//			trace("yy",u,hs[u],v,hs[v]);
		ret[hs[u]]--;
		if(ret[hs[u]]==0)
			ret.erase(hs[u]);
//		hs[u].F=(hs[u].F-P+mod)%mod;
		hs[u].F=(hs[u].F*powmod((hs[v].F+pw[sz[v]])%mod,mod-2,mod))%mod;
//		hs[u].F=(hs[u].F+P)%mod;
//		hs[u].S.F=(hs[u].S.F-P+mod2)%mod2;
		hs[u].S.F=(hs[u].S.F*powmod((hs[v].S.F+pw2[sz[v]])%mod2,mod2-2,mod2))%mod2;
//		hs[u].S.F=(hs[u].S.F+P)%mod2;
//		hs[u].S.S=(hs[u].S.S-P+mod3)%mod3;
		hs[u].S.S=(hs[u].S.S*powmod((hs[v].S.S+pw3[sz[v]])%mod3,mod3-2,mod3))%mod3;
//		hs[u].S.S=(hs[u].S.S+P)%mod3;
		sz[u]-=sz[v];
		ret[hs[u]]++;
		ret[hs[v]]--;
		if(ret[hs[v]]==0)
			ret.erase(hs[v]);
//		hs[v].F=(hs[v].F-P+mod)%mod;
		hs[v].F=(hs[v].F*((hs[u].F+pw[sz[u]])%mod))%mod;
//		hs[v].F=(hs[v].F+P)%mod;
//		hs[v].S.F=(hs[v].S.F-P+mod2)%mod2;
		hs[v].S.F=(hs[v].S.F*((hs[u].S.F+pw2[sz[u]])%mod2))%mod2;
//		hs[v].S.F=(hs[v].S.F+P)%mod2;
//		hs[v].S.S=(hs[v].S.S-P+mod3)%mod3;
		hs[v].S.S=(hs[v].S.S*((hs[u].S.S+pw3[sz[u]])%mod3))%mod3;
//		hs[v].S.S=(hs[v].S.S+P)%mod3;
		ret[hs[v]]++;
		sz[v]+=sz[u];
//		if(u==54019 or v==54019)
//			trace("1",u,hs[u],v,hs[v]);
		dfs1(v,u);
//		if(u==54019 or v==54019)
//			trace("2",u,hs[u],v,hs[v]);
		ret[hs[v]]--;
		if(ret[hs[v]]==0)
			ret.erase(hs[v]);
//		hs[v].F=(hs[v].F-P+mod)%mod;
		hs[v].F=(hs[v].F*powmod((hs[u].F+pw[sz[u]])%mod,mod-2,mod))%mod;
//		hs[v].F=(hs[v].F+P)%mod;
//		hs[v].S.F=(hs[v].S.F-P+mod2)%mod2;
		hs[v].S.F=(hs[v].S.F*powmod((hs[u].S.F+pw2[sz[u]])%mod2,mod2-2,mod2))%mod2;
//		hs[v].S.F=(hs[v].S.F+P)%mod2;
//		hs[v].S.S=(hs[v].S.S-P+mod3)%mod3;
		hs[v].S.S=(hs[v].S.S*powmod((hs[u].S.S+pw3[sz[u]])%mod3,mod3-2,mod3))%mod3;
//		hs[v].S.S=(hs[v].S.S+P)%mod3;
		sz[v]-=sz[u];
		ret[hs[v]]++;
		ret[hs[u]]--;
		if(ret[hs[u]]==0)
			ret.erase(hs[u]);
		hs[u].F=(hs[u].F-P+mod)%mod;
		hs[u].F=(hs[u].F*((hs[v].F+pw[sz[v]])%mod))%mod;
		hs[u].F=(hs[u].F+P)%mod;
		hs[u].S.F=(hs[u].S.F-P+mod2)%mod2;
		hs[u].S.F=(hs[u].S.F*((hs[v].S.F+pw2[sz[v]])%mod2))%mod2;
		hs[u].S.F=(hs[u].S.F+P)%mod2;
		hs[u].S.S=(hs[u].S.S-P+mod3)%mod3;
		hs[u].S.S=(hs[u].S.S*((hs[v].S.S+pw3[sz[v]])%mod3))%mod3;
		hs[u].S.S=(hs[u].S.S+P)%mod3;
		ret[hs[u]]++;
		sz[u]+=sz[v];
	}
}

int main()
{
//	ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

	ll n;
	cin>>n;
	pw[0]=pw2[0]=pw3[0]=1;
	rep(i,1,100009){
		pw[i]=(pw[i-1]*P)%mod;
//		if(pw[i]==1 or pw2[i]==1 or pw3[i]==1)
//			trace(i,pw[i]);
		pw2[i]=(pw2[i-1]*P)%mod2;
		pw3[i]=(pw3[i-1]*P)%mod3;
	}
	rep(i,0,n-1){
		ll u,v;
		cin>>u>>v;
		u--;v--;
		g[u].pb(v);
		g[v].pb(u);
	}

	dfs(0,0);
//	rep(i,0,n)
//		trace(i,hs[i].F);
	ans1=0;
	ans2=-1;
	dfs1(0,0);
	cout<<ans2+1<<endl;
	return 0;
}
