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>
#define REP(i,m) for(int i=0;i<(m);++i)
#define REPN(i,m,in) for(int i=(in);i<(m);++i)
#define ALL(t) (t).begin(),(t).end()
#define CLR(a) memset((a),0,sizeof(a))
#define pb push_back
#define mp make_pair
#define fr first
#define sc second

using namespace std;


#ifndef ONLINE_JUDGE
#define dump(x)  cerr << #x << " = " << (x) << endl
#define prl cerr<<"called:"<< __LINE__<<endl
#define dumpR(x) cerr<<"\x1b[31m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpY(x) cerr<<"\x1b[33m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpG(x) cerr<<"\x1b[32m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
template<class T> void debug(T a,T b){ for(;a!=b;++a) cerr<<*a<<' ';cerr<<endl;}
#else
#define dump(x) ;
#define dumpR(x) ;
#define dumpY(x) ;
#define dumpG(x) ;
#define prl ;
template<class T> void debug(T a,T b){ ;}
#endif

template<class T> void chmin(T& a,const T& b) { if(a>b) a=b; }
template<class T> void chmax(T& a,const T& b) { if(a<b) a=b; }
typedef long long int lint;
typedef pair<int,int> pi;

namespace std{
  template<class S,class T>
  ostream &operator <<(ostream& out,const pair<S,T>& a){
    out<<'('<<a.fr<<','<<a.sc<<')';
    return out;
  }
}

lint readL(){
  lint res;
#ifdef ONLINE_JUDGE
  scanf("%I64d",&res);
#else
  scanf("%lld",&res);
#endif
  return res;
}
void printL(lint res){
#ifdef ONLINE_JUDGE
  printf("%I64d",res);
#else
  printf("%lld",res);
#endif
}


template<lint mod>
struct Int_{
  unsigned x;
  unsigned mpow(Int_ a,unsigned k){
    Int_ res=1;
    while(k){
      if(k&1) res=res*a;
      a=a*a;
      k>>=1;
    }
    return res.x;
  }
  unsigned inverse(Int_ a){
    return mpow(a,mod-2);
  }
  Int_(): x(0) { }
  Int_(long long sig) {
    int sigt=sig%mod;
    if(sigt<0) sigt+=mod;
    x=sigt;
  }
  unsigned get() const { return (unsigned)x; }
  
  Int_ &operator+=(Int_ that) { if((x += that.x) >= mod) x -= mod; return *this; }
  Int_ &operator-=(Int_ that) { if((x += mod - that.x) >= mod) x -= mod; return *this; }
  Int_ &operator*=(Int_ that) { x = (unsigned long long)x * that.x % mod; return *this; }
  Int_ &operator=(Int_ that) { x=that.x; return *this;}
  Int_ &operator/=(Int_ that) { x=(unsigned long long) x * inverse(that.x)%mod; return *this;}
  bool operator==(Int_ that) const { return x==that.x; }
  bool operator!=(Int_ that) const { return x!=that.x; }

  Int_ operator-() const { return Int_(0)-Int_(*this);}
  Int_ operator+(Int_ that) const { return Int_(*this) += that; }
  Int_ operator-(Int_ that) const { return Int_(*this) -= that; }
  Int_ operator*(Int_ that) const { return Int_(*this) *= that; }
  Int_ operator/(Int_ that) const { return Int_(*this) /= that; }
  Int_ inv(){
    return Int_(mpow(x,mod-2));
  }

};

namespace std{
  template<lint mod>
  ostream &operator <<(ostream& out,const Int_<mod>& a){
    out<<a.get();
    return out;
  }
  template<lint mod>
  istream &operator >>(istream& in,Int_<mod>& a){
    in>>a.x;
    return in;
  }
};

typedef Int_<1000000007> Int1;
typedef Int_<1000000009> Int2;
typedef Int_<1000000021> Int3;
typedef Int_<1000000033> Int4;

struct H{
  Int1 a;
  Int2 b;
  Int3 c;
  Int4 d;
  bool operator <(const H& X) const{
    if(a.x!=X.a.x) return a.x<X.a.x;
    if(b.x!=X.b.x) return b.x<X.b.x;
    if(c.x!=X.c.x) return c.x<X.c.x;
    return d.x<X.d.x;
  }
  H operator +(const H& X) const{
    return (H){a+X.a,b+X.b,c+X.c,d+X.d};
  }
  H operator *(const H& X) const{
    return (H){a*X.a,b*X.b,c*X.c,d*X.d};
  }
};

//const int INF=5e8;
int n;
vector<int> g[100005];
const lint mod=1000000007;

H var[100005],hashh[100005],phashh[100005];
int dep[100005],pdep[100005];
map<H,int> memo;
int app;
void add(H a){
  dump(a.a);dump(a.b);dump(a.c);
  memo[a]++;
  if(memo[a]==1) ++app;
}
void del(H a){
  memo[a]--;
  if(memo[a]==0) --app;
}

H unit=(H){1,1,1,1};
void dfs(int v,int p){
  dep[v]=0;
  for(auto to:g[v]){
    if(to==p) continue;
    dfs(to,v);
    chmax(dep[v],dep[to]+1);
  }
  hashh[v]=unit;
  for(auto to:g[v]){
    if(to==p) continue;
    hashh[v]=hashh[v]*(var[dep[v]]+hashh[to]);
  }
  if(v) add(hashh[v]);
}

H inv(H x){
  return (H){x.a.inv(),x.b.inv(),x.c.inv()};
}

int val[100005];
void dfs2(int v,int p){
  val[v]=app;
  pi mxi={-1,-1},sec={-1,-1};
  if(~p){
    mxi={pdep[v],p};
  }
  
  for(auto to:g[v]){
    if(to==p) continue;
    if(mxi.fr<dep[to]){
      sec=mxi;
      mxi={dep[to],to};
    }else if(sec.fr<dep[to]){
      sec={dep[to],to};
    }
  }
  H X=var[mxi.fr+1],Y=var[sec.fr+1];

  H allX=unit,allY=unit;
  if(~p){
    allX=phashh[v]+X;
    allY=phashh[v]+Y;
  }
  for(auto to:g[v]) if(to!=p){
    allX=allX*(hashh[to]+X);
    allY=allY*(hashh[to]+Y);
  }
  for(auto to:g[v]){
    if(to==p) continue;
    if(mxi.sc==to){
      dump(X.a);dump(X.c);
      dump(hashh[to].a);
      dump(hashh[to].c);
      dump(((hashh[to]+X)*inv(hashh[to]+X)).c);
      H tmp=allY*inv(hashh[to]+Y);
      phashh[to]=tmp;
    }else{
      H tmp=allX*inv(hashh[to]+X);
      phashh[to]=tmp;
    }
    del(hashh[to]);
    add(phashh[to]);
    dfs2(to,v);
    del(phashh[to]);
    add(hashh[to]);
  }
}

int main(){
  cin>>n;
  REP(i,n) var[i]=(H){rand()%mod,rand()%mod,rand()%mod,rand()%mod};
  REP(i,n-1){
    int a,b;scanf("%d%d",&a,&b);--a;--b;
    g[a].pb(b);
    g[b].pb(a);
  }
  dfs(0,-1);
  prl;
  dfs2(0,-1);



  debug(val,val+n);
  int res=max_element(val,val+n)-val;
  cout<<res+1<<endl;
  return 0;
}



