package main

import (
	"fmt"
	"os"
	"sort"
)

var (
	buffer    [1 << 16]byte
	bufferLen int
	bufferPtr int
)

func readByte() byte {
	if bufferPtr >= bufferLen {
		n, _ := os.Stdin.Read(buffer[:])
		if n == 0 {
			return 0
		}
		bufferLen = n
		bufferPtr = 0
	}
	b := buffer[bufferPtr]
	bufferPtr++
	return b
}

func readInt() int {
	b := readByte()
	for b <= ' ' {
		if b == 0 {
			return 0
		}
		b = readByte()
	}
	res := 0
	for b > ' ' {
		res = res*10 + int(b-'0')
		b = readByte()
	}
	return res
}

func main() {
	n := readInt()
	if n == 0 {
		return
	}

	head := make([]int, n+1)
	for i := range head {
		head[i] = -1
	}

	type edge struct {
		to   int
		next int
	}
	edges := make([]edge, 0, 2*n-2)

	addEdge := func(u, v int) {
		edges = append(edges, edge{to: v, next: head[u]})
		head[u] = len(edges) - 1
	}

	for i := 0; i < n-1; i++ {
		u := readInt()
		v := readInt()
		addEdge(u, v)
		addEdge(v, u)
	}

	var leaves []int

	var dfs func(u, p, d int)
	dfs = func(u, p, d int) {
		isLeaf := true
		for e := head[u]; e != -1; e = edges[e].next {
			v := edges[e].to
			if v != p {
				isLeaf = false
				dfs(v, u, d+1)
			}
		}
		if isLeaf {
			leaves = append(leaves, d)
		}
	}

	maxTime := 0
	for e := head[1]; e != -1; e = edges[e].next {
		v := edges[e].to
		leaves = leaves[:0]
		dfs(v, 1, 1)
		sort.Ints(leaves)

		cur := 0
		for _, d := range leaves {
			if cur < d {
				cur = d
			} else {
				cur++
			}
		}
		if cur > maxTime {
			maxTime = cur
		}
	}

	fmt.Println(maxTime)
}