```go
package main

import (
	"io"
	"os"
	"strconv"
)

const LOG = 21

var data []byte
var ptr int
var up [LOG][]int32
var depth []int32

func nextInt() int {
	for ptr < len(data) && (data[ptr] < '0' || data[ptr] > '9') {
		ptr++
	}
	n := 0
	for ptr < len(data) && data[ptr] >= '0' && data[ptr] <= '9' {
		n = n*10 + int(data[ptr]-'0')
		ptr++
	}
	return n
}

func lca(u, v int32) int32 {
	if depth[int(u)] < depth[int(v)] {
		u, v = v, u
	}
	diff := int(depth[int(u)] - depth[int(v)])
	for k := 0; k < LOG; k++ {
		if (diff>>k)&1 == 1 {
			u = up[k][int(u)]
		}
	}
	if u == v {
		return u
	}
	for k := LOG - 1; k >= 0; k-- {
		uu := up[k][int(u)]
		vv := up[k][int(v)]
		if uu != vv {
			u = uu
			v = vv
		}
	}
	return up[0][int(u)]
}

func dist(u, v int32) int32 {
	w := lca(u, v)
	return depth[int(u)] + depth[int(v)] - 2*depth[int(w)]
}

func addNode(parent int32, n *int32) int32 {
	*n = *n + 1
	x := *n
	px := int(x)
	pp := int(parent)
	depth[px] = depth[pp] + 1
	up[0][px] = parent
	for j := 1; j < LOG; j++ {
		up[j][px] = up[j-1][int(up[j-1][px])]
	}
	return x
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	q := nextInt()

	maxN := 2*q + 6
	depth = make([]int32, maxN)
	for i := 0; i < LOG; i++ {
		up[i] = make([]int32, maxN)
	}

	for v := 2; v <= 4; v++ {
		depth[v] = 1
		up[0][v] = 1
		for j := 1; j < LOG; j++ {
			up[j][v] = up[j-1][int(up[j-1][v])]
		}
	}

	var n int32 = 4
	var a, b int32 = 2, 3
	var dia int32 = 2

	out := make([]byte, 0, q*8)

	for i := 0; i < q; i++ {
		v := int32(nextInt())

		x := addNode(v, &n)
		da := dist(x, a)
		db := dist(x, b)
		if da > dia || db > dia {
			if da >= db {
				b = x
				dia = da
			} else {
				a = x
				dia = db
			}
		}

		y := addNode(v, &n)
		da = dist(y, a)
		db = dist(y, b)
		if da > dia || db > dia {
			if da >= db {
				b = y
				dia = da
			} else {
				a = y
				dia = db
			}
		}

		out = strconv.AppendInt(out, int64(dia), 10)
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}
```