Once upon a time there was only one router in the well-known company Bmail. Years went by and over time new routers were purchased. Every time they bought a new router, they connected it to one of the routers bought before it. You are given the values p_i — the index of the router to which the i-th router was connected after being purchased (p_i < i).

There are n routers in Boogle in total now. Print the sequence of routers on the path from the first to the n-th router.

Input

The first line contains integer number n (2 ≤ n ≤ 200000) — the number of the routers. The following line contains n-1 integers p_2, p_3, ..., p_n (1 ≤ p_i < i), where p_i is equal to index of the router to which the i-th was connected after purchase.

Output

Print the path from the 1-st to the n-th router. It starts with 1 and ends with n. All the elements in the path should be distinct.

Examples

Input

8
1 1 2 2 3 2 5


Output

1 2 5 8 

Input

6
1 2 3 4 5


Output

1 2 3 4 5 6 

Input

7
1 1 2 3 4 3


Output

1 3 7 
import java.util.*;

public class BMailComputerNetwork {
    static List<Integer> router[] ;
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        router=new LinkedList[num]; //must initialized

        for (int i = 0; i < num-1; i++) {
            int n= sc.nextInt();
            router[i]=new LinkedList<>();
            router[n-1].add(i+1);  //n-1 point to respective router
        }

       /* for (int i = 0; i < num-1; i++) {   //list
            Iterator<Integer> connectList=router[i].listIterator();
            System.out.print(i+1+ "    ");
            while(connectList.hasNext())
                System.out.print(connectList.next()+1+ " ");
            System.out.println();
        }*/
        //to show a vertex with respective child node

        Stack<Integer> path=new Stack<>();
        boolean [] visited=new boolean[num];
        path=dfs(0,path,visited);

        Stack<Integer> temp=new Stack<>();
        while(!path.isEmpty()){
            temp.push(path.pop()+1);
        }

        while(!temp.isEmpty()){
            System.out.print(temp.pop()+ " ");
        }

    }

    private static Stack<Integer> dfs(int i, Stack<Integer> path, boolean[] visited) {
        int goal = router.length - 1;
        path.push(i);
        visited[i] = true;

        try {   //router[i] may be null
            Iterator<Integer> child = router[i].listIterator();

          /*  if(router[i]==null && i!=goal){
                path.pop();
                return path;
            }*/
            while (child.hasNext()) {

                int s = child.next();
                if (!visited[s])
                    dfs(s, path, visited);

            }
        }catch(NullPointerException e) {
        };
        if(path.peek()==goal)
            return path;
        path.pop();    //no child node and not goal node, remove from stack
        return path;
    }


}