package main

import (
	"fmt"
	"io"
	"math/bits"
	"os"
)

type fastReader struct {
	data []byte
	pos  int
}

func newFastReader(r io.Reader) *fastReader {
	data, _ := io.ReadAll(r)
	return &fastReader{data: data, pos: 0}
}

func (r *fastReader) nextInt() int {
	for r.pos < len(r.data) && r.data[r.pos] <= ' ' {
		r.pos++
	}
	if r.pos >= len(r.data) {
		return 0
	}
	res := 0
	for r.pos < len(r.data) && r.data[r.pos] > ' ' {
		res = res*10 + int(r.data[r.pos]-'0')
		r.pos++
	}
	return res
}

func main() {
	r := newFastReader(os.Stdin)
	n := r.nextInt()
	if n == 0 {
		return
	}

	parent := make([]int, n+1)
	for i := 2; i <= n; i++ {
		parent[i] = r.nextInt()
	}

	head := make([]int, n+1)
	next := make([]int, n+1)
	for i := n; i >= 2; i-- {
		p := parent[i]
		next[i] = head[p]
		head[p] = i
	}

	s := make([]int, n+1)
	for i := 1; i <= n; i++ {
		s[i] = 1
	}
	for i := n; i >= 2; i-- {
		s[parent[i]] += s[i]
	}

	count := make([]int, n+1)
	var items []int
	var distinct []int
	var bs []uint64

	var totalAns int64

	for u := 1; u <= n; u++ {
		S := s[u] - 1
		if S <= 0 {
			continue
		}

		maxChild := 0
		for v := head[u]; v != 0; v = next[v] {
			if s[v] > maxChild {
				maxChild = s[v]
			}
		}

		if maxChild >= S/2 {
			totalAns += int64(maxChild) * int64(S-maxChild)
			continue
		}

		distinct = distinct[:0]
		items = items[:0]

		for v := head[u]; v != 0; v = next[v] {
			c := s[v]
			if count[c] == 0 {
				distinct = append(distinct, c)
			}
			count[c]++
		}

		for _, w := range distinct {
			c := count[w]
			count[w] = 0
			k := 1
			for c > 0 {
				if k > c {
					k = c
				}
				items = append(items, w*k)
				c -= k
				k *= 2
			}
		}

		target := S / 2
		words := target/64 + 1
		if len(bs) < words {
			newSize := words * 2
			if newSize < 16 {
				newSize = 16
			}
			bs = make([]uint64, newSize)
		}
		for i := 0; i < words; i++ {
			bs[i] = 0
		}
		bs[0] = 1

		for _, v := range items {
			if v > target {
				continue
			}
			wordShift := v / 64
			bitShift := uint64(v % 64)

			if bitShift == 0 {
				for i := words - 1; i >= wordShift; i-- {
					bs[i] |= bs[i-wordShift]
				}
			} else {
				compShift := 64 - bitShift
				for i := words - 1; i > wordShift; i-- {
					bs[i] |= (bs[i-wordShift] << bitShift) | (bs[i-wordShift-1] >> compShift)
				}
				bs[wordShift] |= (bs[0] << bitShift)
			}
		}

		w := target / 64
		b := target % 64
		var mask uint64
		if b == 63 {
			mask = ^uint64(0)
		} else {
			mask = (uint64(1) << (b + 1)) - 1
		}

		val := bs[w] & mask
		if val != 0 {
			highestBit := bits.Len64(val) - 1
			ans := w*64 + highestBit
			totalAns += int64(ans) * int64(S-ans)
		} else {
			for i := w - 1; i >= 0; i-- {
				if bs[i] != 0 {
					highestBit := bits.Len64(bs[i]) - 1
					ans := i*64 + highestBit
					totalAns += int64(ans) * int64(S-ans)
					break
				}
			}
		}
	}

	fmt.Println(totalAns)
}