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

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Div1_395D {

	public static void main(String[] args) throws IOException {
		POW = new long[500_000];
		POW[0] = 1;
		for (int i = 1; i < 500_000; i++) {
			POW[i] = POW[i - 1] * BASE % MOD;
		}
		new Div1_395D().main();
	}

	ArrayList<Edge> aList[];
	ArrayList<Edge> rList[];

	int[] numI;
	boolean[] inQ;

	ArrayDeque<Integer> queue = new ArrayDeque<Integer>();

	HashMap<Long, Long> cnts = new HashMap<Long, Long>();

	int maxV = -1;
	long maxC = -1;

	void main() throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter printer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int nV = Integer.parseInt(reader.readLine());

		aList = new ArrayList[nV];
		for (int i = 0; i < nV; i++) {
			aList[i] = new ArrayList<>();
		}

		for (int i = 0; i < nV - 1; i++) {
			StringTokenizer inputData = new StringTokenizer(reader.readLine());
			int a = Integer.parseInt(inputData.nextToken()) - 1;
			int b = Integer.parseInt(inputData.nextToken()) - 1;

			Edge p = new Edge(a, b);
			Edge q = new Edge(b, a);
			p.opp = q;
			q.opp = p;

			aList[a].add(p);
			aList[b].add(q);
		}

		numI = new int[nV];
		inQ = new boolean[nV];

		for (int i = 0; i < nV; i++) {
			if (aList[i].size() == 1) {
				inQ[i] = true;
			}
		}

		for (int i = 0; i < nV; i++) {
			if (aList[i].size() == 1) {
				inQ[i] = false;
				calculate(i);
			}
		}

		while (!queue.isEmpty()) {
			int cur = queue.remove();
			inQ[cur] = false;
			calculate(cur);
		}

		dfs1(0, -1);
		dfs2(0, -1);

		printer.println(maxV + 1);
		printer.close();
	}

	void dfs2(int cV, int pV) {
		if (cnts.size() > maxC) {
			maxC = cnts.size();
			maxV = cV;
		}

		for (Edge aE : aList[cV]) {
			if (aE.e == pV) {
				continue;
			}
			Long aKey = aE.hash;
			Long prev = cnts.get(aKey);
			cnts.put(aKey, prev == null ? 1 : prev + 1);

			Long rKey = aE.opp.hash;
			prev = cnts.get(rKey);
			if (prev == 1) {
				cnts.remove(rKey);
			} else {
				cnts.put(rKey, prev - 1);
			}

			dfs2(aE.e, cV);

			// undo
			aKey = aE.opp.hash;
			prev = cnts.get(aKey);
			cnts.put(aKey, prev == null ? 1 : prev + 1);

			rKey = aE.hash;
			prev = cnts.get(rKey);
			if (prev == 1) {
				cnts.remove(rKey);
			} else {
				cnts.put(rKey, prev - 1);
			}
		}
	}

	void dfs1(int cV, int pV) {
		for (Edge aE : aList[cV]) {
			if (aE.e == pV) {
				continue;
			}
			Long key = aE.opp.hash;
			Long prev = cnts.get(key);
			cnts.put(key, prev == null ? 1 : prev + 1);

			dfs1(aE.e, cV);
		}
	}

	void calculate(int cV) {
		Collections.sort(aList[cV], BY_OUT_HASH);
		if (numI[cV] == aList[cV].size() - 1) {
			long hash = '(';
			int len = 1;

			for (int i = 1; i < aList[cV].size(); i++) {
				hash = (hash * POW[aList[cV].get(i).opp.len] + aList[cV].get(i).opp.hash) % MOD;
				len += aList[cV].get(i).opp.len;
			}
			hash = (hash * BASE + ')') % MOD;
			len++;

			aList[cV].get(0).hash = hash;
			aList[cV].get(0).len = len;

			if (++numI[aList[cV].get(0).e] >= aList[aList[cV].get(0).e].size() - 1 && !inQ[aList[cV].get(0).e]) {
				queue.add(aList[cV].get(0).e);
				inQ[aList[cV].get(0).e] = true;
			}
		} else {
			long[] sufH = new long[aList[cV].size() + 1];
			sufH[aList[cV].size()] = ')';
			int[] sufL = new int[aList[cV].size() + 1];
			sufL[aList[cV].size()] = 1;

			for (int i = aList[cV].size() - 1; i >= 0; i--) {
				sufH[i] = (aList[cV].get(i).opp.hash * POW[sufL[i + 1]] + sufH[i + 1]) % MOD;
				sufL[i] = aList[cV].get(i).opp.len + sufL[i + 1];
			}

			long hash = '(';
			int len = 1;

			for (int i = 0; i < aList[cV].size(); i++) {
				if (aList[cV].get(i).hash == -1) {
					aList[cV].get(i).hash = (hash * POW[sufL[i + 1]] + sufH[i + 1]) % MOD;
					aList[cV].get(i).len = len + sufL[i + 1];

					if (++numI[aList[cV].get(i).e] >= aList[aList[cV].get(i).e].size() - 1
							&& !inQ[aList[cV].get(i).e]) {
						queue.add(aList[cV].get(i).e);
						inQ[aList[cV].get(i).e] = true;
					}
				}

				hash = (hash * POW[aList[cV].get(i).opp.len] + aList[cV].get(i).opp.hash) % MOD;
				len += aList[cV].get(i).opp.len;
			}
		}
	}

	class Edge {
		int s;
		int e;
		Edge opp;
		long hash = -1;
		int len;

		Edge(int s, int e) {
			this.s = s;
			this.e = e;
		}
	}

	final Comparator<Edge> BY_OUT_HASH = new Comparator<Edge>() {
		public int compare(Edge e1, Edge e2) {
			return Long.compare(e1.opp.hash, e2.opp.hash);
		}
	};

	static final long MOD = 1_000_000_000 + 123;
	static final long BASE = 34447759;
	static long[] POW;

}
