Problem: Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.

The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.

All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.

To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.

Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.

Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.

It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.

Input

The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).

The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).

Output

In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).

In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).

In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.

Examples

Input


5
0 0 1 1


Output


0 2 1 4 3
2
1 3


Input


4
0 1 2


Output


0 1 2 3
0

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.util.LinkedList;
import java.util.Comparator;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskF solver = new TaskF();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskF {
        int N;
        List<Integer>[] graph;
        int[] parent;
        int[] lowest;
        int[] height;
        List<Integer> order;
        LinkedList<Integer> operations;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            N = in.nextInt();
            graph = new List[N];
            parent = new int[N];
            lowest = new int[N];
            height = new int[N];
            for (int i = 0; i < N; i++) {
                graph[i] = new ArrayList<Integer>();
            }
            for (int i = 1; i < N; i++) {
                int p = in.nextInt();
                parent[i] = p;
                graph[p].add(i);
            }
            dfs(0);
            order = new ArrayList<>();
            operations = new LinkedList<>();
            dfs1(0);
            for (int u : order) {
                out.print(u + " ");
            }
            out.printLine();
            out.printLine(operations.size());
            for (int u : operations) {
                out.print(u + " ");
            }
            out.printLine();
        }

        public void dfs1(int u) {
            order.add(u);
            int w = -1;
            for (int v : graph[u]) {
                dfs1(v);
                if (w != -1) {
                    int node = lowest[w];
                    while (node != u) {
                        operations.addLast(v);
                        node = parent[node];
                    }
                }
                w = v;
            }
        }

        public void dfs(int u) {
            if (graph[u].size() == 0) {
                lowest[u] = u;
                height[u] = 0;
            } else {
                height[u] = -1;
                for (int v : graph[u]) {
                    dfs(v);
                    if (height[u] < height[v] + 1) {
                        height[u] = height[v] + 1;
                        lowest[u] = lowest[v];
                    }
                }
                Collections.sort(graph[u], new Comparator<Integer>() {

                    public int compare(Integer o1, Integer o2) {
                        if (height[o1] != height[o2]) {
                            return height[o1] - height[o2];
                        } else {
                            return 1;
                        }
                    }
                });
            }
        }

    }

    static class OutputWriter {
        PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer tokenizer = null;

        public InputReader(InputStream inputStream) {
            in = new BufferedReader(new InputStreamReader(inputStream));
        }

        public String next() {
            try {
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    tokenizer = new StringTokenizer(in.readLine());
                }
                return tokenizer.nextToken();
            } catch (IOException e) {
                return null;
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}