package main

import (
	"bufio"
	"io"
	"os"
	"sort"
)

func readInt(data []byte, idx *int) int {
	n := len(data)
	for *idx < n && (data[*idx] < '0' || data[*idx] > '9') {
		*idx++
	}
	x := 0
	for *idx < n && data[*idx] >= '0' && data[*idx] <= '9' {
		x = x*10 + int(data[*idx]-'0')
		*idx++
	}
	return x
}

func writeInt(w *bufio.Writer, x int) {
	if x == 0 {
		w.WriteByte('0')
		return
	}
	var buf [20]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	w.Write(buf[i:])
}

func writeInt64(w *bufio.Writer, x int64) {
	if x == 0 {
		w.WriteByte('0')
		return
	}
	var buf [24]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	w.Write(buf[i:])
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	n := readInt(data, &idx)

	parent := make([]int, n)
	children := make([][]int, n)
	for v := 1; v < n; v++ {
		p := readInt(data, &idx)
		parent[v] = p
		children[p] = append(children[p], v)
	}

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

	for u := 0; u < n; u++ {
		if len(children[u]) > 1 {
			ch := children[u]
			sort.Slice(ch, func(i, j int) bool {
				if sz[ch[i]] != sz[ch[j]] {
					return sz[ch[i]] < sz[ch[j]]
				}
				return ch[i] < ch[j]
			})
		}
	}

	order := make([]int, 0, n)
	pos := make([]int, n)
	stack := make([]int, 0, n)
	stack = append(stack, 0)
	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		pos[u] = len(order)
		ch := children[u]
		for i := len(ch) - 1; i >= 0; i-- {
			stack = append(stack, ch[i])
		}
	}

	var k int64
	for v := 1; v < n; v++ {
		k += int64(pos[v] - pos[parent[v]] - 1)
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	for i, v := range order {
		if i > 0 {
			w.WriteByte(' ')
		}
		writeInt(w, v)
	}
	w.WriteByte('\n')

	writeInt64(w, k)
	w.WriteByte('\n')

	first := true
	for i := len(order) - 1; i >= 1; i-- {
		v := order[i]
		c := pos[v] - pos[parent[v]] - 1
		for j := 0; j < c; j++ {
			if !first {
				w.WriteByte(' ')
			}
			first = false
			writeInt(w, v)
		}
	}
	w.WriteByte('\n')
	w.Flush()
}